Script/binary-encoded-character processing method and system with moving space insertion mode

ABSTRACT

A pen-based processor needs to be usable to input and edit script like a text-based computer but retain a resemblance to the user of a pad and pencil. The pen-based computer implements input, editing and other manipulation of glyphs including handwritten script, ASCII test, bitmapped images and drawings in a common document, using a compatible internal representation of the data and a simple, consistent set of user control functions. These functions are invoked using an intuitive and interactive set of user gestures which do not distract the user from the task of inputting or editing the document. A two-step gesture method avoids confusion between strokes and command gestures and allows use of similar gestures for different functions within the same and different contexts. The system infers from customary user writing conventions that certain relationships of data are to be preserved and maintains the relationships, subject to user override, during editing. The display document is formatted to contain both lined areas of glyphs that can be edited, including insertion of a moving space into pre-existing document text and word wrapping. Adjoining unlined drawing areas are unaffected by editing of lined area contents.

RELATED APPLICATION DATA

This application is a continuation-in-part of co-pending U.S.application Ser. No. 07/673,292, filed Mar. 20, 1991, forSCRIPT/BINARY-ENCODED-CHARACTER PROCESSING METHOD AND SYSTEM.

BACKGROUND OF THE INVENTION

This invention relates generally to pen-based computer systems and moreparticularly to an interactive method for entry and editing of script,text and drawings in a document display.

Script refers to handwritten characters and words. Text refers totypewritten characters and words and includes binary-encoded characterssuch as ASCII text. Drawings refers to hand drawn sketches but can alsoinclude imported drawings originally drawn by or on a machine.

Existing pen-based systems use gestures to edit exclusively script orASCII text (i.e., not both interchangeably or simultaneously). They arelimited, moreover, to gestures that by their form, context, or locationcan be distinguished from the data that they act upon. For instance,free-form gestures applied to ASCII text are recognizable because theASCII exists in what can be termed a different plane. Free form gesturesapplied to selected script are recognizable because pen actionsfollowing a selection are assumed to be gestures OR because writingapplied to a selected area is assumed to be a gesture. Free-formgestures occurring within a gesture sensitive area of the screen areeasily recognized. Otherwise, prior systems require an explicit actionto initiate gesture recognition especially within script such asselection of text or scrip or keyboard or similar input of a controlcommand. One could alternatively designate a set of unique strokes todefine gesture commands, but this approach requires interpretation ofall strokes during script entry which is compute-intensive and virtuallyprecludes mixing script, ASCII text and sketches.

Editing of untranslated script in existing systems is typicallyrestricted to opening up space between characters or words, erasingcharacters or words, and applying enhancements to pieces of script(e.g., underline, bold, etc.). No known prior pen-based system enablesscript words to be word-wrapped, let alone doing it with mixed scriptand ASCII text. Developers have probably been reluctant to attemptscript word wrap for the following reasons:

Processing strokes consumes a lot of CPU time making it difficult toprovide whole screen word wrapping reflow and display in a timelymanner.

Strokes consume a lot of memory.

A word wrapping algorithm for handwritten script is unheard of, to saynothing of one that can maintain the user's spacing of strokes (words).

A technique is not available for opening space within a line of scriptfor the user to write additional script and automatically providing morewriting space as the user writes (i.e., a "moving" space).

Certain pieces of information that delimit paragraphs and preservehorizontal/vertical whitespace during word wrap must somehow existwithin the script document. The common approach to adding this sort ofinformation to a document involves explicitly delimiting paragraphs andspecifying whitespace, neither of which is conducive to the free flow ofthoughts while writing.

Mixing ASCII and script text with graphics requires a gesture set thatfunctions the same with both types of text and is not confused withscript writing or graphics drawing. Mixing ASCII with script text in thesame edit plane is not known to have been done before, although systemsare known in which a script annotation plane allows users to overlayexisting ASCII documents with script comments.

ASCII text editing systems have typically been character-based, using acursor to control positioning. Script, by its nature, makescharacter-based editing very difficult. A cursor is not needed withscript because of the direct referencing characteristics of a pen. Asystem that mixes both script and ASCII text must be able to handle thecharacter nature of ASCII as well as the free-form nature of script.

Script is composed of strokes; pen movements captured as the stylustraces a character outline on a digitizing tablet. A script charactercan contain one or more strokes. Each stroke must be captured and itscharacteristics maintained in a stroke database. The typical method forthis is called the time-order method. The time-order method haslimitations, however. This method can lead to misinterpreted characters,depending on how the characters are created. Accordingly, a new approachis required which would eliminate the ordering of strokes merely by thepoint in time in which they are created.

Another drawback to current art for capturing pen-based stroke datainput is the inability of current systems to wrap words and maintainpredesignated spacing between words that have wrapped on to a subsequentline. This causes a loss of the user's writing characteristics,resulting in material that is less readable to the person who wrote it.Accordingly, a method is required to maintain predesignated spacebetween words after word wrapping to successive lines occurs.

A system could determine the amount of space between script words bymonitoring stroke data input in real time; analyzing the data usingpattern recognition techniques, and accordingly developing a method foridentifying word separation space. This, however, requires complexsoftware and hardware capability beyond that of the typical pen-basedtechnology commercially available. Accordingly, a method is requiredwhich reliably captures word spacing without complex computer analysisof stroke data.

Accordingly, a need remains for a better way to enter, store, manage andedit handwritten script, or preferably script and binary-encoded text,in a pen-based computer system.

SUMMARY OF THE INVENTION

One object of the invention is to provide an improved pen-based computersystem and script editing process.

Another object is to recognize stroke/ASCII character clusters or unitsthat might represent words or embedded drawings.

A related object is to ascertain word boundaries in order to performword editing functions such as word wrap while maintaining the user'sword spacing.

Another object is to provide an intuitive interactive user interface fora pen-based computer.

A further object is to specify editing commands within freeformscript/drawings such that the commands are not confused with thescript/drawings and the user interface retains the look and feel of apiece of paper.

An additional object is to interpret the meaning of script/ASCII textpositions within a document being written or a document that has beenscanned/FAXed and provide editing features without destroying the subtleinformation inherent in the layout of a page of text.

Yet another object is to enable a user to continually enter data into adocument, including into pre-existing script or text, without having toperform explicit actions to acquire additional open (blank) writingspace.

A script/binary-encoded-character processor (or simply script/textprocessor) preferably includes a script/ASCII text editor, support forcreating drawings, and optionally an outliner. The processor also hassimple page layout capabilities implemented through vertical andhorizontal margin settings.

The basic script or script/text processing method can be implemented ina variety of software forms suited to different operating systems suchas PenPoint from GO Corp. of Foster City, Calif., and PenWindows fromMicrosoft Corp. of Bellevue, Wash., or without an operating system butwith similar program features for accessing and controlling hardwarecomponents. The processor can provide character/word translation intoASCII text using, e.g., GO Corp. software. A wide range of hardwareconfigurations can be used to implement the processor of the invention.

Input to the script/text processor can take many forms: writing with apen (stylus) on a digitizer connected to a computer; existing or storeddocuments; documents from character (keyboard) based word processors;FAX transmissions and scanned documents. A word processor specificprogram converts the character-based document to a form recognizable bythe processor. The FAX contents are recognized by the script/textprocessor and converted to the processor document format. The samealgorithm that recognizes FAX contents will recognize the contents ofscanned images.

Output from the processor can likewise take many forms including:script/text documents; ASCII files; printed images; FAX transmissions.

Input/Output to the processor can be from/to a storage medium (e.g., adisk) or some sort of network connection (e.g., a LAN or telephonelines). The processor software can be implemented in a concurrentversion that allows multiple computer users to interactively edit thesame document.

One aspect of the invention is that an efficient stroke compressionalgorithm is provided, so that documents can contain many pages ofuntranslated script, as well as ASCII text. Since pen strokes can becaptured at high resolutions (200+ dots per inch), the method ofcompressing strokes was devised so as to retain the information neededto perform translation of script into "ASCII" characters. A method wasalso devised for converting FAX or scanned documents into thescript/text document format. The compression method commences with the"root" of each stroke, which is defined relative to the line space towhich the stroke is connected. Strokes are preferably rooted in the linespace where the pen first touched when the stroke was made, but a stroke"center of gravity" (or some similar type of algorithm) could also oralternatively be used to determine in which line a stroke should berooted. The method also allows ascenders and descenders (e.g., tail on"g") to cross over line boundaries while still remaining rooted in ahome line.

Another aspect of the invention is that the script/text processorrecognizes word boundaries within the script text and, preferably, canalso recognize the implicit layout of text lines within a document. Thisaspect enables the processor to provide editing/word processing featuresthat prior to this invention were not available for handwrittendocuments. It can also facilitate outlining. Additionally, because thescript/text processor of the invention can manipulate words as images,script or text containing more than one language (shorthand could beconsidered a different language) can be edited (provided both languagesuse similar editing conventions, such as word wrapping forward from theright end of a line of text).

The method for managing word wrapping presents a novel solution to thecurrent technical problems associated with determining word boundariesand managing word spacing. One aspect of the method provides a defaultword spacing value called a break point gap which can be assignedthrough a plurality of mechanisms at the outset of stroke data capture.Another aspect of the method employs a comparative analysis of whitespace between points of stroke data with the default break point gapvalue. A third aspect employs a monitoring mechanism for maintainingword spacing regardless of whether word wrapping has occurred.

Another aspect of the invention is a method that enables the user to usea single gesture set to manipulate both script and ASCII text, and evendrawings, all within a single document. Since word translation can occurin the background as the user writes, a document can contain both scriptand ASCII text. Or an ASCII document can be imported and edited, e.g.,by addition of script.

Other pen-based systems are known to use a set of stylus gestures forediting functions. Rather than limiting gestures to editing only ASCII,or to gestures formed so as not to be construed as script (whichinterferes with embedding drawings in a document), however, the presentinvention uses a two-step interactive approach to inputting andinterpreting an editing gesture. The first step is to initiate atransitory gesture mode prompt. Once that mode is initiated (and,preferably, but not essentially, a gesture prompt is displayed), asecond step is to accept a following stylus movement or gesture as acommand. Upon completion of the gesture, the gesture mode automaticallyterminates. This approach is functional for editing both script andASCII (any binary encoded text or data), and drawings as well.

Also, rather than using compound or unique gestures (e.g., a caret, apigtail, etc.), straightline vertical and horizontal gestures arepreferred. The gesture set used in the invention is selected toimplement an intuitive relationship between the gestures and therespective functions to be performed.

The gesture set is also context-sensitive as between text and graphicalediting, depending on whether the stylus is in a lined writing area oran open (unlined) drawing area of the document. Furthermore, differentinitial pen actions can be used to obtain different gesture modeprompts. In each case, subsequent gestures initiate different functions,depending on location/context and form of gesture prompt. This allows asimple set of gestures to be used easily to perform a variety offunctions. The gesture set allows quick and easy corrections of mistakesby the algorithms that recognize word boundaries and text layout.

Another aspect of the invention enables the user to enter scriptcontinually without having to explicitly request additional blank spaceor move existing script that is in the path of script to be entered.Alternatively, the user can select a mode to enter script without havingto shift arm position. In other words, the user can continually write ona single physical line of the input device while the software keepstrack of and provides new (blank) logical line spaces.

The invention also enables the user to perform simple page layoutoperations in order to intersperse free-form drawing areas (non-ruledblocks of lines) with text areas (ruled blocks of lines) on a documentpage. The processor of the invention further allows graphics images tobe drawn and interspersed within line spaces among script/ASCII text.These images can "word wrap" along with the text in which they areimbedded.

The script/text processor's feature set disclosed herein is tailored forthe typical user. If an editing or script-entry error occurs, the usersimply corrects it, using other editing functions. One can providefunctionality desired by the less common user by adding self-teachingfeatures to the algorithms. Typical users of the invention would bepeople who want to quickly jot down notes with/without drawings; peoplewho need to make drawings along with descriptive text, e.g., engineers,lab workers, coaches; people who want to quickly record/revise ideas asdiscussions progress, e.g., students; writers that do not want to leaveany trace of writing that has been revised, e.g., letter writers,confidential communications; and people who desire to represent theirviews of the world in a hierarchical manner through the use of anoutline. The information being represented hierarchically can be script,text and/or drawings, including structured diagrams.

Another class of user is the writer who does not compose documents atthe keyboard (e.g., doctors on rounds, shop-floor supervisors,executives, people who cannot or prefer not to type). Documents willtypically be composed in script and handed off to a secretary fortranslation/typing into ASCII text. The secretary may then download theASCII document into the script/text processor for a round of revision bythe author. Downloaded documents can be read, annotated, and editedbefore being electronically returned to the secretary or publisher.

The foregoing and other objects, features and advantages of theinvention will become more readily apparent from the following detaileddescription of a preferred embodiment of the invention which proceedswith reference to the accompanying drawings.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram of a PC with a pen-based script/text entry andediting system according to the invention.

FIG. 2 is a block diagram of a free-standing pen-based computer systemincorporating the present invention.

FIG. 3 is a state diagram of various events in the operation of theinvention and FIGS. 3A-3F are flow charts of the process substepsresponsive to each of the events of FIG. 3.

FIGS. 4 and 4A-4H are diagrams of gestures used in the invention forediting script and/or text in the editing mode of FIG. 3, and FIG. 4Ishows the preferred set of gestures used in editing and select modes ofgesture control.

FIG. 5A is a diagram illustrating word-separation concepts used in wordwrapping and FIG. 5B is a diagram showing wrap-gap management in theinvention.

FIGS. 6A-6D are diagrams of the script bit-mapping and compressionprocess.

FIG. 7 is a diagram of a typical document display formatted, accordingto the invention and FIGS. 7A-7U are a sequential series of displayscreens showing a script/text document in the system of FIG. i asvarious editing functions are performed.

FIG. 8 is a preferred set of command icons and corresponding functionsused in the present invention.

FIG. 9 is a diagram of a method for encoding script and ASCII text ininternal document format according to the invention.

FIG. 10 is a diagram showing a method of text entry in a pen-basedcomputer system.

FIGS. 11A-11E are diagrams illustrating the opening, use and closing ofmoving space.

APPENDICES A through E are combination pseudocode and structured Englishsubroutines for implementing the Insert/Collapse Moving Space command.

DETAILED DESCRIPTION

The following description outlines various hardware and softwareenvironments in which the handwritten script and text (e.g., ASCII)processing software of the invention can be implemented. Next describedin subsequent sections are script/text document and page attributes; theevent-driven process used to implement the method word boundaries andwrapping; beginning-of-line designation; processing of ASCII text;interword space management including break point gap analysis, wordwrapping and wrap-gap manipulation; gesture-based editing; conversion ofstrokes to internal stroke format using an efficient script compressiontechnique and representation of ASCII text in internal stroke format,concluding with an example showing a series of editing processes in anoperational pen-based system according to the invention.

Preferred Hardware Environment

FIG. 1 shows a personal computer (PC) 10 having a graphics input devicesuch as a digitizer 12 that is sensitive to a pen or stylus 14 that canbe used to enter script and editing gestures in a document containingscript and/or ASCII text. This computer has a document display screen 16distinct from its pen sensitive digitizer and can include a printer 18or other output device. FIGS. 7 and 7A-7U show document pages from sucha screen as used in the invention.

The graphics input device is preferably but need not be capable ofentering script. It can be merely a pointing device, e.g., a mouse,light pen, touch pad, keyboard cursor, etc., used to edit existingdocuments containing script/ASCII or to create and edit documents usinga keyboard (not shown) for text entry. The presently preferred inputdevice is a digitizer which is responsive both to stylus contact (pendown), position and stylus proximity (pen close--e.g., 1/2" or 1 cm.)such as the WACOM 50-510C digitizer and stylus, U.S. Pat. No. 4,786,765.Alternatively, a digitizer and stylus that is contact, position andpressure sensitive could be used, such as made by Summagraphics Corp.,U.S. Pat. No. 4,786,764. A further alternative input device isresponsive to stylus angle as well as being contact, position andpressure sensitive. In a computer having a keyboard with cursor keys,key action can be mapped to the editing gesture control functions,allowing documents containing script and/or ASCII to be edited from thekeyboard as well as the graphics input device. Documents can be createdusing the keyboard for text entry and edited in script form.

FIG. 2 shows a notebook sized computer 20 with integrated display anddigitizer 22 that is responsive to a pen (stylus) 24, and an outputdevice shown in this instance as a FAX/Modem 26.

Other hardware that can be used include:

A FAX machine with integrated display and digitizer that is connected toa computer and responsive to a pen (stylus);

A Whiteboard/Blackboard type of display having an integrated digitizerthat is responsive to a pen (stylus) and connected to a computer; or

A pen sensitive digitizer and light transmissive display panel (e.g.,LCD) connected to a computer and positioned as an overlay on an overheadprojector. A similar device is marketed that allows pen-type input butdrives the overhead projector rather than being light transmissive; thistoo could employ the present invention.

Preferred Software Environment

The presently preferred software for carrying out the method of theinvention is shown in FIGS. 3-3F and further described below.

This software can be implemented in a number of alternative softwareenvironments. The invention has been implemented in C language on a386-based personal computer running GO Corporation's PenPoint OperatingSystem, and is transferrable to Microsoft's Pen Windows OperatingSystem.

It can also be implemented on any other operating system that canprovide information on pen (stylus) activity, including an operatingsystem such as MSDOS or OS/2, that provides graphics input device and/orkeyboard feedback. The invention can also be used in a computer that hasno operating system but has the ability to access and control thehardware components attached to a computer system via software commands.This can include sensing stylus position on a digitizer, capturingkeystrokes on a keyboard, or outputting graphic images onto a display.

Script/Text Document and Page Attributes

FIG. 7 shows a document display screen 30. A script/text document 32 inaccordance with the invention comprises multiple pages for entry andediting of script/ASCII text with or without embedded drawings, as shownin FIGS. 7A-7U. The user is able to "screen" page, "paper" page orscroll through the document. The user can also write a page numberwithin a translation area to directly reference that page. A "Find" menuoption can search the document for a specific ASCII string (in thefuture "fuzzy fit" script string searches can also be provided).

A script/text document could also be a single page, with margin-lessinput or lined area comprising one or more lines. This "document" mightserve as a component in a larger application.

As shown in FIG. 7, a page of document 32 typically contains a group ofruled lines 34 defining line spaces 39 that allow script/ASCII textentry and editing, above each line. The lines each have beginning andending points 36, 38 defining line length. The lines as a group define alined area. Preferably visible to the user, the processor can include anoption to hide the lines while retaining their attributes.

Portions of the page that are not ruled are considered to be margin ordrawing areas, although it is permissible to imbed drawings within linesof text. The drawing areas include left and right margins 40, 42 and topand bottom margins 44, 46. The top and bottom margins as shown includetwo unruled line spaces each. The user can change the size and positionof the text and drawing areas, including the number of lines spaces, ifany, used as top and bottom margins.

Within the text (ruled) areas, word wrapping can occur. A user is freeto write or draw anywhere on a page but should keep in mind that largedrawings (i.e., drawings with a height of two or more lines) in thelined area might be broken up during word wrap, and text in a drawingarea cannot word wrap. Pages are separated by non-hard page breaks 48which allow word wrapping between adjoining pages.

The line spaces and their respective contents are maintained as units ina tree-type data structure that allows traversal to extract the unitsserially for presentation in the document display. Other data structurescould be used but this one is advantageous for supporting outlining.

Automatic control code insertion allows the user to write on ascript/text document as would normally be done on a piece of paper, withthe processor taking care of the line-by-line formatting. This isaccomplished by the processor watching where, when, and how the userplaces his strokes. For instance, if a user writes on a line, skips aline, and then writes on the following line, then it can be assumed thatthe user wants the blank (skipped) line to remain blank. Editingfeatures such as word wrapping would not overwrite the blank line. Thisfeature and its use with static (scanned/FAXED) images is described inmore detail in the section entitled Beginning of Line Designation.

A menu or gesture-selectable script processing feature, positioncontrol, allows the user to continuously write within a certain area onthe display without having to perform "explicit" actions (e.g.,scrolling) to position the input area. The input area will be positionedfor the user by automatic scrolling. (Note that scrolling up (manual orautomatic) at the end of the document causes blank lines to be appendedto the document). Automatic scrolling will typically be triggered by penout of proximity.

Some varieties of the feature are, once the boundaries of auser-specified screen area have been exceeded, pen out of proximity willcause the document to scroll so that the input area again resides withinthe screen area boundaries. Another version has pen out of proximitywithin the document causing scrolling equivalent to the number of linesused (blank lines written on) since the last pen out of proximity. Ananalogous gesture can also be provided that performs the same functionas pen out of proximity, for use with graphic input devices that are notproximity-sensitive.

A preferred set of basic editing gestures and their functions aredescribed in the section below entitled Gesture Based Editing anddemonstrated in an operational processor in Example 3 and FIGS. 7A-7U.The next section describes the processor software diagrammed in FIGS. 3and 3A through 3F.

Description of Event-Driven Process

FIG. 3 shows the main process of the present invention. The various penor stylus digitizer events that drive the application are described asfollows:

    ______________________________________                                        Pen Down:  Event is generated when the stylus                                            contacts the digitizing surface.                                   Pen Up:    Event is generated when the stylus loses                                      contact with the digitizing surface.                               Pen Move:  Event is generated when the stylus moves                                      while in contact with the digitizing                                          surface.                                                           Pen Stroke:                                                                              Event is generated when user completes a                                      stroke with the stylus along the                                              digitizing surface.                                                Pen Out of Event generated when the stylus, already                           Proximity: out of contact with the digitizing                                            surface, leaves proximity (i.e., the                                          sensing range of the digitizer) jp18.                                         The stylus is in proximity when it is                                         within a distance approximately one half                                      inch of the digitizing surface. This                                          distance can be varied.                                            Pen Double Event generated when the pen contacts                              Tap:       the digitizing surface at approximately                                       the same position twice within a fixed                                        time period.                                                       ______________________________________                                    

FIGS. 3A-3E flow chart the process substeps initiated by each event. Atany time during the process of FIG. 3, the timer subprocess of FIG. 3Fcan assert an interrupt to initiate a gesture command sequence.

Referring to FIG. 3A, the Pen Down event causes recordal of the pen downlocation and starts a timer for detecting a gesture prompt. The timeridentity is recorded and, referring to FIG. 3F, if this timer times outbefore another timer is set then the system generates a gesture promptat the pen down location. Then the subprocess returns to the mainprocess and awaits the next event.

In the case of a Pen Up event, the subprocess of FIG. 3B sets the latesttimer to zero (which invalidates the gesture timing process of FIG. 3F),records the pen up location, and returns to the main process.

The Pen Moved event initiates the subprocess of FIG. 3C, to determinewhether line space needs to be opened and, if so, to open space, wrapdownstream line space contents to subsequent lines, update the display,and return to the main process. This subprocess is further describedbelow in Detailed Description of Moving Space Processing. If the pen hasmoved by more than a predetermined amount (i.e., changed location), thelatest timer is set to zero, which invalidates the gesture prompt timerof FIG. 3F.

The Pen Stroke event initiates the subprocess of FIG. 3D. Thissubprocess causes the pen stroke to be interpreted either as a writingstroke, in which case script strokes are processed and displayed (ink isdribbled), or as a gesture, which in turn is interpreted and acorresponding command function is executed, as described below. Eachbranch in the subprocess concludes by updating the display and returningto the main process.

The Pen Out of Proximity event causes the subprocess of FIG. 3E to resetthe latest timer to zero and then initiates a scrolling function.

Further details of the software implementation will be understood andprogrammable by persons skilled in programming pen-based systems byreference to the procedures diagrammed in FIGS. 3A-3F. The basic editinggestures are shown in FIGS. 4A-4H and their respective functions aredescribed below. It will also be appreciated that these procedures canbe varied, for example, to add gestures (see FIGS. 3D(b) and 3D(c), orto substitute different forms of events suited to different kinds ofpen-based input devices (e.g., Pen Vertical instead of Pen Out ofProximity).

Beginning of Line Designation

Text, script and script/text documents consist of words, physical lines(where words reside), and blank space. The script/text processorcurrently formats all documents using only Beginning Of Line (BOL)markers. BOL markers are inserted automatically whenever the user'sscript entry implies that a new line of script has been started.

What the BOL marker does is protect the text and/or script on the linewhere it resides from being shifted to a new horizontal position duringword wrap reflow of the document. That is, words pushed from a precedingline will not wrap onto the beginning of the line containing a BOLmarker. Instead, the entire latter line is pushed down and a whole newline is opened to receive the pushed-down words from the preceding line.In the case of blank lines, BOL markers are used to assure that the linewill remain blank during word wrap reflow. Ordinarily, these markers arenot visible but optionally may be displayed.

A user can also explicitly insert a BOL marker (see FIG. 4C andassociated description). Unlike a carriage-return/line-feed symbol whichthe user must explicitly insert in conventional ASCII text processing,however, the BOL marker is ordinarily inferred from text position and isautomatically input. This is important for a pen-based system so thatthe handwriting user need not insert control characters.

How words are arranged on lines and how lines of script are arranged ona page by a user has significant meaning. Without factoring in when andhow the following words came to be in their current position, we candetermine whether to insert a BOL marker at the beginning of each lineof text (or script) data in the following example document:

    ______________________________________                                        Line                                                                          ______________________________________                                        1         This is an example document which has a                             2         total of nine lines.                                                4         A list can help one remember:                                       5                                                                             do this                                                                       6                                                                             then this                                                                     7                                                                             8            Signed,                                                          9             Signature                                                       ______________________________________                                    

Line 1: Insert BOL marker because this is the first line in thedocument.

Line 2: Do not insert BOL marker because no space was available at theend of the preceding line for the first word on this line.

Lines 3,7: Insert BOL marker because lines are blank and are followed bynon-blank lines.

Line 4: Insert BOL marker because this is the first line following ablank line.

Lines 5,6: Insert BOL marker because preceding line does not containtext (has blank space) for a statistically significant distance prior tothe right margin.

Lines 8,9: Insert BOL marker because text is substantially indented.

The example document could have been a scanned or FAXed document thatwas converted to script/text processor document format before being"statically" formatted by the processor. It could have also been adocument that was dynamically formatted as the user entered scriptand/or text. Situations like the following might then have occurred:Line 2, having been left blank while the text on the following lines wasentered, had a BOL marker inserted. The user then decided to enter texton line 2. Having done so, line 2 would have its BOL marker removed forthe same reason that a BOL marker was not inserted in the first example.Now if the user wanted a BOL marker to be inserted at the beginning ofline 2, the insert BOL gesture could be used at the end of line 1 (seeFIG. 4C). Because this would be an explicit insertion of the BOL marker,automatic line formatting would not remove the BOL marker--the userwould have the option of removing it with the delete space/BOL markergesture (see FIG. 4B).

Any time the user touches the pen to the document portion of the screen,ink will be available for writing/drawing. If a character/wordtranslation process is enabled and the user writes in the text area,translation of script to ASCII text will occur in the background. Thetranslated characters will replace the script and can be edited in thesame way as the script. Editing features for script/ASCII text anddrawings are available to the user through gestures, icons, and menuchoices.

Text Processing in Script/Text Document

For illustration, let us assume that user wants to write a mixedscript/ASCII document using the processor of the invention. Startingwith a blank piece of "paper," as shown in FIG. 7, a user will typicallyconstruct a script/ASCII document by entering the script text (cursiveor printed) and having it translated to ASCII in the background. Anotherway is if the user manually edits a pre-existing ASCII document byinsertion of script. Edits can be made to either the script or ASCIItext as further described below.

In order to be able to perform word-oriented editing operations on bothscript and ASCII text with a single gesture set, the script and ASCIIportions of a document both need to be represented as a series of words.In both handwritten and printed ASCII documents, words are separated bya larger amount of space than that which separates the characters withina word. The larger amount of space between words is the basis upon whichthe processor decides where a word begins.

The script/text processor could decide how much space to look forbetween script words by watching how the user spaces words as writingoccurs, basically learning what type of spacing to expect, but a simplerapproach is used effectively in the present invention.

The present method provides the user with a default word spacing value(which can be determined by watching the user write a line (e.g., thefirst line) of text.) This value specifies a default break point gap(BPG) or spacing which defines a space between words of script, andthereby defines "words," per se. Unlike the space in typed text (e.g.,produced by an ASCII space-bar character) the break point gap is definedby the physical word spacing in script, which is variable in length. Theprocessor enables the user to adjust the word spacing value (i.e., theprocessor's BPG) to his personal script word spacing (i.e., to theuser's own BPG).

The processor orders strokes/ASCII character images within a line bytheir left-most point (pixel) position. Accordingly, the word spacingvalue (BPG) specifies the amount of space that must exist between theleft-most point (pixel) of a stroke or ASCII character image and theright-most point of all the preceding strokes and/or ASCII characterimages on the line in order for the stroke/ASCII character beingexamined to be recognized as the first stroke/ASCII character of a word(see example in FIG. 5A).

The user can increase this value if it is found that partial words arebeing recognized as words. Or the user can decrease this value if it isfound that multiple words are being recognized as a single word. Thisapproach has been found to be highly reliable once the user finds a goodpersonal word spacing value. Keep in mind that the word spacing value isused for recognizing where a word begins (and thus where the precedingword must have ended). The spacing that the user gives words whilewriting is maintained although inter-word space compaction or expansioncould be applied to position words on a line.

Word spacing within ASCII text is far more consistent than withinscript. The word spacing is usually different from that of script,depending upon differences in the relative size of the script and ASCIItext. The processor maintains a separate word spacing value for ASCIItext. This value is essentially determined by looking at the ASCIIcharacter size values resulting from the font+point size selection. Theuse of multiple font+point sizes in a document will require that a wordspacing value exist for each font plus point size combination. Within astring of text of a particular font plus point size, only theappropriate word spacing value will be used to determine wordboundaries. As script is translated into ASCII, the processor assigns aword spacing that is appropriate for the font plus point size. This doesnot restrict the user from inserting additional space between words byusing the space insertion gesture, nor does it restrict the user fromremoving space between words by using the space deletion (erasure)gesture. Space inserted between script or ASCII words can only help theword recognition process, whereas space deletion can hinder the process.

When an ASCII document is downloaded into the processor, it must beconverted to the processor's internal document format in order for it tobe manipulated using the edit gestures. Paragraph boundaries are easilydetermined in ASCII documents because they are typically demarcated byexplicitly-used carriage-return line-feed characters. Word boundariesare also easily determined in ASCII documents because the ASCII spacecharacter is used to separate words.

When a scanned or FAX document is downloaded into the processor, it mustalso be converted to the processor's internal document format. Thetechniques used to determine word boundaries described above are alsoused to determine word boundaries once line boundaries have beenrecognized within the input document.

EXAMPLE 1

Assuming the following BPG values: script word spacing value: 9 units;ASCII word spacing value: 6 units. FIG. 5A shows a line of cursive andprinted script and ASCII text created by the user in which the processorrecognizes word boundaries using the following criteria:

(A) First stroke/ASCII character image is always recognized as thebeginning of a word.

(B) 10 units exist between left-most point of "P" and right-most pointof all preceding strokes/ASCII character images on the line. Since 10 isgreater than or equal to the script word spacing value, "P" isrecognized as the beginning of a word.

(C) Not enough blank space for "N" to be recognized as the first letterin a word.

(D) Whether script or ASCII word spacing value is used for comparisondepends on the ratio of the ASCII character image dimensions whencompared to the script dimensions.

(E) 6 units exist between left-most point of the ASCII character image"t" and the right-most point of all preceding strokes/ASCII characterimages on the line. Since 6 is greater than or equal to the ASCII wordspacing value, "t" is recognized as the beginning of a word. Note:Proportionally spaced ASCII characters would require a word spacingvalue specific to each adjacent ASCII character pair.

The next three sections describe a preferred implementation of thisaspect of the invention in further detail.

Gesture-Based Editing

A context-sensitive gesture set is provided for editing text anddrawings. The user is free to write or draw anywhere on a page, butshould keep in mind that large drawings in a text (ruled) area might bebroken up during word wrap and text in a drawing area cannot word wrap.

Gestures are pen movements used to tell the processor control program todo something. This invention uses a two-part gesture. The first partinitiates gesture control; the second part is the gesture itself. Theprocessor allows the user to perform a pen action within the document toindicate that a control gesture is going to be made that should not beinterpreted as an additional text/drawing stroke. The pen actionstimulates feedback by causing display of a gesture prompt. The threeprimary ways (although there are many more) to get a gesture prompt are:(1) touch the tip of the pen (stylus) to the digitizer surface and holdit in this position for a split second; (2) tap the digitizer surfacewith the tip of the pen and then touch the tip of the pen to thedigitizer surface at approximately the same position as the tap; or (3)in a system in which pen angle is sensed, a particular pen position(e.g., vertical) can be used to initiate a gesture prompt. Note that aspecific pen action need not be tied to a specific gesture prompt. Theuser can be provided with a way of mapping pen actions to gestureprompts (and thus gesture classes). This would, for instance, allow theuser to use the most efficient and/or comfortable pen actions to performthe gesturing tasks currently at hand. The user could then remap the penactions to a different gesture class and proceed to use those same penactions to efficiently and/or comfortably do something else.

When one of the above actions occurs, a visible gesture prompt symbolwill be presented to the user. The gesture prompt symbol can take a formassociated with the class of gestures that it represents. For action (1)above, the preferred prompt is a filled circle 50 at the pen downlocation as shown in FIGS. 4-4I. Action (2) can be used to get aselection gesture prompt in the form of a vertical bar 52 (FIG. 4I). So,in addition to being context sensitive, gestures are "prompt sensitive."The particular shape of the prompt displayed to the user can be varied(see FIG. 4I) and it is not essential to display a prompt symbolalthough very much preferred.

After seeing the prompt, the user moves the pen in a selected direction51 (FIG. 4) to invoke a desired function. For the prompts and associatedgestures described within this patent application, the tip of the pen isheld to the digitizer surface beginning with the prompt and continuingthrough the gesture. For other prompts and gesture classes, the pen maynot need to remain in contact with the digitizer surface. For instance,an "object drawing" prompt could be followed by the entry of multipleline segments, with the gesture recognition algorithm examining eachline segment until a particular geometric shape (e.g., square, triangle,circle, etc.) was recognized. At that point in time, the user would bepresented with a high quality representation of the recognized shape andthe gesture would be complete (unless the object drawing prompt was usedto enter a mode (drawing mode) that must be explicitly exited usinganother gesture).

For many gestures, gesture recognition can occur before the gesture iscompletely drawn. The gestures described in this application were chosenfor many reasons, one being that they can be recognized as they arebeing made. This allows gesture feedback to be provided to the user atthe earliest possible time. When the user makes a gesture, immediatefeedback that corresponds to the type of gesture being made will beprovided.

For example, a selection gesture can cause the selected line space andstrokes/words to be highlighted in some way, such as by drawing atransitory line that follows the gesture as shown in FIG. 7D, or byinverse video or bolding the selected line space and script or text.With sufficient computing speed, the selected command function can beexecuted as the gesture is being made. For instance, a line insertiongesture could cause blank lines to be inserted and displayed as the usermakes the gesture. This sort of feedback is highly desired by the user.

Following is a description of the preferred gesture set as shown inFIGS. 4A-4H and the control and edit functions for each gesture.

Insert Space Gesture 54 (FIG. 4A)

This gesture inserts (opens up) an amount of space on the gesture lineequivalent to the length of the gesture stroke. Words pushed off the endof the line wrap to the next line.

Delete Space Gesture 56 (FIG. 4B)

This gesture deletes (collapse) space/strokes underneath the gesturestroke. Words from following lines may wrap back to the gesture line ifit is permissible to remove words from the following lines (i.e., nointervening BOL marker). If this gesture follows all strokes on a line,words will be allowed to wrap back to the gesture line from thefollowing line even if they previously were disabled from doing so by aBeginning of Line marker.

Insert Beginning of Line (BOL) Marker Gesture 58 (FIG. 4C)

All strokes (words) following this gesture are wrapped forward to thenext line. No words from preceding lines will be allowed to wrap ontothis "protected" line unless the Beginning of Line marker is removed.The number of markers inserted depends on the distance of the gesturestroke. Multiple BOL markers will appear to the user as blank lines.

Delete Line Contents Gesture 60 (FIG. 4D)

This gesture deletes the text (ruled) area contents of each line touchedby the gesture stroke.

Mark Block Gesture 62 (FIG. 4E)

Two separate gestures are required after the gesture prompt to mark ablock of text. The first gesture marks the beginning/end of the blockand the second gesture marks the end/beginning of the block. The markblock gesture line must stay within the confines of the ruled line lestit be recognized as an Insert BOL marker gesture. Ink dribbling, paging,scrolling, etc. can occur between the beginning and end mark gestures.

Insert/Collapse Moving Space Gesture (FIG. 4F)

The insert moving space gesture consists of lifting the pen out ofcontact with the digitizer surface without moving it laterally, afterthe gesture prompt. This gesture is used to open up an indefinite ormoving amount of space within a line of script or text so the user caninsert additional script or text. About 1.5 inches (6 cm.) of space willbe opened immediately to the right of the pen down position initiallyupon recognition of the gesture. After the space opens, the user lowersthe pen and begins writing. As the user writes, additional space willautomatically be provided in order to accommodate continuing strokes.This method can be called "auto-insertion." Any words pushed off the endof the initial pen-down line by the auto-insertion will be wrapped tothe following line. Repeating this gesture (i.e., prompt plus lift pen)collapses the moving space.

Note that actions resulting from the foregoing gestures, when located inthe lined area of the document display, will in no way affect drawingsin the unlined drawing areas surrounding or adjoining thegesture-modified text. The gesture set is context-sensitive, however, sothat the same gesture can be used in the unlined areas to perform eitherdifferent editing functions or similar functions only in the drawingarea, i.e., without affecting contents of adjoining lined area.

Line Insertion Gesture (see FIG. 7Q)

The Line Insertion Gesture is like the Insert BOL gesture 58 (FIG. 4C)but is located in the unlined margin alongside a line. A whole line(text area +drawing area) or multiple lines will be inserted in thelined area laterally adjoining the gesture location shifting all linesbelow it downward within the document. This will cause the last line oneach affected document page to be shifted over the bottom and topmargins (if any) to the first line of the next document page. Theinserted line takes on the characteristics (ruled area margins, etc.) ofthe line/ruler that precedes it. Multiple lines can be inserted byextending the distance that the gesture covers.

Line Deletion Gesture (see FIG. 7S)

This gesture is like gesture 60 (FIG. 4D) but performed in the margin. Awhole line will be deleted from the document, shifting all lines belowit upward within the document. This will cause the first line on eachsucceeding document page to be shifted up over the top and bottommargins (if any) to the last line on the preceding document page.Multiple lines can be deleted by extending the distance that the gesturestroke covers. This gesture can also be used to delete the contents of atop/bottom margin line, although the margin line itself will not bedeleted. The gesture can be used to delete a ruler, causing the linesfollowing the deleted ruler to be formatted according to the rulerpreceding the deleted ruler.

Stretching Box Gesture 64 (FIG. 4G)

The Stretching Box Select gesture (which might also or alternatively berepresented by an icon) selects all drawing area strokestouched/enclosed by the rectangular area.

Rope Select Gesture 66 (FIG. 4H)

The Rope Select gesture (might also be represented by icon) selects alldrawing area strokes touched/enclosed by roped area.

Prompt-Specific Gesture Sets

Multiple unique gesture prompts allow for the classification ofgestures. Each specific gesture motion can be associated with one ormore prompts (pen actions). In FIG. 4I, two unique prompt images areshown, each with a set of gesture pen motions. Note that the first fivegestures in each set is unique in function although the gestures areidentical motions. The last three gestures in each set are similar inboth motion and function.

Another interesting aspect of the gesture set shown in FIG. 4I is that,with the exception of Pen Up and Mark Block, all of the gesture motionscan be recognized as specific gestures (given the context in which theyare currently supported) even before the gesture is completed! Thisallows dynamic feedback to be provided to the user as the user performsthe gesture (e.g., showing increasing amounts of whitespace and wordwrapping as the user inserts space). The current implementation of thesoftware waits for the user to complete gestures before acting uponthem. Future versions will utilize multi-tasking to provide dynamicfeedback that is highly responsive to the pen.

Selected Strokes

A variety of functions can be applied to selected strokes in text ordrawing area. These functions are available through menu selection:delete, cut, copy, paste, highlight (bold, outline, etc.), translate(from script into ASCII), evaluate (math expressions), etc. In addition,selected strokes can be dragged by touching the pen to the selectedstrokes and dragging. Strokes can be selected by invoking the I-beamgesture prompt 52 (FIG. I) and dragging it through the stroke(s) to beselected.

Additional editing tools can be provided and represented by suitableicons. All tools are picked up, used one or more times, and thenreturned to their original places. A preferred set of tools and examplesof corresponding icons are shown in FIG. 8.

Ruler 70

The user picks up the ruler icon in order to insert a ruler. A rulerwill be inserted at the pen down position within the document.

Highlight 72

The highlight marker is used to highlight strokes. The highlight remainson the strokes until it is explicitly removed by the user through repeat(inverse) highlighting or SELECT, choose new highlight. Multiplehighlight markers or a single "multicolored" highlight marker may existto accommodate different highlighting needs.

Pointing Finger 74

The pointing finger is used to select text. It can be used in place ofthe drag select gesture if desired. It is different from the drag selectgesture in that it allows the user to select more than one piece oftext.

Eraser 76

The eraser erases pixels within text or drawing areas without collapsingblank space. The eraser can come in different sizes to erase pixelswaths of different widths.

Rubberband line 78

The rubberband line is provided so that the user can draw straight lineswithin the text or drawing area without the use of a template orstraightedge.

Circle

The circle allows the user to draw variable sized circles within thetext or drawing area without the use of a template.

Open Drawing Space Left 82, Full-Width 84 and Right 86

These icons are invoked to change line lengths to increase the availableunlined drawing space in an adjoining margin, or to extend the drawingspace all the way across the page.

Stroke Eraser 88

The stroke eraser will erase only the pixels of strokes, not affectingany ASCII text. This is quite useful when annotating documents thatexist primarily in an ASCII text form.

Conversion of Strokes to Internal Stroke Format

Following is a description, with reference to FIGS. 6A-6D, of howstrokes go from being input glyphs to residing within the softwaresystem as meaningful data in accordance with another aspect.

For simplicity, the following description assumes that lines are storedat screen (raster) resolution. As shown in FIG. 6A, the document existsin a window (a bit-mapped display area having its origin in the lowerleft corner) having a series of logical lines, the first line beingnumbered 1 and succeeding lines having increasing line numbers (throughline N). The document is displayed with lower document line numbers(e.g., lines 4, 5, 6) appearing at the top of the window and documentline numbers increasing as document lines are displayed toward thebottom of the window (e.g., line N+3). At any point in time the windowrepresents a viewport onto a certain number of document lines. The exactlocation of the viewport onto the document is maintained by keepingtrack of the first (topmost) document line (e.g., line 4) that will beviewable in the window.

When a stroke is stored into the document, the document line into whichthe stroke will be rooted must be determined. The process requires a fewsteps:

The first step is to determine which window line the stroke belongs to.A number of methods exist for mapping a stroke to a certain window line(e.g., center of gravity) but for purposes of simplicity (and because itworks pretty well) let us assume that a stroke belongs to the line inwhich the pen tip first touched the digitizer. The window line is thendetermined using the following equation:

    ______________________________________                                        WLN =               ((FRR - PDYV)/RRPL) + 1                                   in which: WLN =     Window Line Number;                                       FRR =               First Raster Row;                                         PDYV =              Pen Down Y Value; and                                     RRPL =              Raster Rows Per Line.                                     ______________________________________                                    

Now that the window line number has been determined, the document linethat the stroke belongs to can be determined by the following equation:

    DL=(TDL+WL)-1

in which:

DL=Document Line;

TDL=Topmost Document Line; and

WL=Window Line

Once the document line is determined, the document line needs to beretrieved from the document line database.

With the document line in hand, the relative position of the strokewithin the line must be determined. Due to the nature of the strokecompression method used to store strokes (it stores points within astroke relative to the first point of the stroke), only the first pointof a stroke needs to be assigned a position within the document line.The position will be relative to the line's left margin for the X-axisand relative to the bottom-most "raster" row owned by the document linefor the Y-axis. This position can be identified by relative coordinatesX' and Y'. The actual X and Y values used to anchor the stroke within adocument line are determined using the following equations:

    ______________________________________                                        X:       window X coordinate for first point in stroke                        Y:       window Y coordinate for first point in stroke                        X' =     X - left margin window X coordinate for the                                   document line                                                        Y' =     Y - ((FRR + 1) - (WL * RRPL))                                               in which:                                                                            FRR = First Raster Row;                                                       WL = Window Line; and                                                         RRPL = Raster Rows Per Line                                     ______________________________________                                    

Now that the coordinates used to anchor a stroke within a document linehave been determined, the next step is to compress the remaining pointsof the stroke. Any compression algorithm used must retain thepoint-to-point directional information inherent in strokes if thosestrokes are to be translated into ASCII text or used to characterizehandwriting at some point in the future.

The basic assumption behind the processor compression algorithm is thatstrokes have momentum--a stroke is more likely to continue moving in aspecific direction than it is likely to move in a dramatically differentdirection. This allows compression of a stroke by representing pointincrements within the stroke with predefined values that reveal anychange in direction. For instance, the binary value 1 would mean:continue forward one point in the current direction. The binary value 00would mean: move forward and to the left of the current direction by onepoint, causing the current direction to be redefined by the newdirection. The binary value 01 would mean: move forward and to the rightof the current direction by one point, causing the current direction tobe redefined by the new direction. Visually it might look like FIG. 6B.

EXAMPLE 1

The arrows in FIG. 6B represent the current direction after the point ateach arrow position has been encoded. The initial direction fromstarting point "x" is encoded per the binary values shown in FIG. 6C.The actual encoding of the circle shown would be a concatenation of thefollowing binary directional data:

    ______________________________________                                        01011   Point count in stroke less 1 (Note: This is the                               binary length of the stroke; it can be up to,                                 e.g., 32 data points)                                                 000     Direction from starting point "x" to point 2                                  (Note: the starting point is recorded as an X-Y                               coordinate. This is the "root" point of the                                   stroke. This direction is the current direction                               at point 2.)                                                          01      Direction change needed to get to point 3                                     (Note: 01 shows a change to the right; 00 would                               be to left.)                                                          1       Continue in current direction to get to point 4                       01      Direction ohange needed to get to point 5                             01      Direction change needed to get to point 6                             1       Continue in current direction to get to point 7                       01      Direction change needed to get to point 8                             01      Direction change needed to get to point 9                             1       Continue in current direction to get to point 10                      01      Direction change needed to get to point 11                            01      Direction change needed to get to point 12                            25      bits                                                                  ______________________________________                                    

This algorithm requires that all points in a stroke be adjacent. Therecan be no gaps or adjacent points having the same coordinates (duplicatepoints). In order to assure that there are no gaps, a line drawingalgorithm is employed to fill any gaps in a stroke (typically due tomoving the pen too fast) with a straight line before any attempt is madeto compress the stroke. To remove duplicate points, which typicallyresult from digitizing at high resolution and translating to a lowerresolution, any duplicate points exceeding one are discarded at eachposition.

In order for this type of compression to be most efficient, thedigitized strokes need to be smoothed. For instance, extraneous points,which result from digitizing at high resolution and translating to alower resolution, need to be removed before the compression algorithm isapplied. These extraneous points can be detected by searching througheach stroke for formations that give the appearance of an "L" (two linesmeeting at right angles. This search uses the matrix shown in FIG. 6D.

An "L" formation in FIG. 6D would be any series of points that fall intoa 1, 2, 3 sequence. As a stroke is compressed, each point of the stroke(actually each point that is retained after the "L" formation lookahead)takes its turn in the "1" position. If the following 2 points make an"L" formation, then one of them must be discarded. The point to bediscarded is determined by examining the position of a 3rd pointfollowing the point in the "1" position. This third point is not shownin FIG. 6D but could appear anywhere within the matrix (except in the"3" position because duplicate points have been removed) or asurrounding ring of points around the matrix. Of the points in the "2"and "3" positions, the one farthest from the third point (i.e., thepoint requiring the largest change in X and Y coordinate values to reachthe third point) is discarded.

The compression algorithm as described requires that strokes exceeding32 points (only 5 bits in point count) be broken into a series of"ministrokes." It also requires strokes having too radical a change ofdirection for direction change encoding to be broken into ministrokes,as in the case of a script "M." The resulting ministrokes arecompression encoded as described above. Alternatively (or also), thestroke length could be set at 64 points (6 bits) or more for higherresolution digitizers. These encoded ministrokes are then concatenatedto form the whole stroke, the last point of each ministroke being the`start point` of a succeeding ministroke.

A variation on this stroke compression method allows for compression ofstrokes having less momentum (i.e., many closely spaced directionchanges). An expanded set of encoding values is employed:

EXAMPLE 2

    ______________________________________                                        1:     Move forward one point in the current direction                        000:   Move 1 point counterclockwise from the current                                direction and forward. The new direction becomes                              the current direction.                                                 001:   Move 2 points counterclockwise from the current                               direction and forward. The new direction becomes                              the current direction.                                                 010:   Move 1 point clockwise from the current direction                             and forward. The new direction become the current                             direction.                                                             011:   Move 2 points clockwise from the current direction                            and forward. The new direction becomes the                                    current direction.                                                     ______________________________________                                    

After bridging gaps within a stroke, removing duplicate points anddiscarding extraneous "L" pattern points, the circle used in the firstcompression example would be compressed and encoded as follows:

    ______________________________________                                        01011   Point count in stroke less 1                                          000     Direction from starting point to point 2                              010     Change direction to right to get to point 3                           1       Continue in current direction to find point 4                         010     Change direction to right and down to get                                     to point 5                                                            010     Change direction to down to get to point 6                            1       Continue in current direction to get to point 7                       010     Change direction left and down to get to point 8                      010     Change direction to left to get to point 9                            1       Continue in current direction to point 10                             010     Change direction to up and left to                                            get to point 11                                                       010     Change direction to up to get to point 12                             32      bits                                                                  ______________________________________                                    

As can be seen, the first compression method compresses the examplestroke much more than the second compression method. This will notalways be the case. Certain strokes will be compressed more using thesecond method rather than the first, for instance a stroke that variesmore widely in direction than the example stroke. The point is that theprogram can analyze the stroke characteristics before applying a certaincompression method to the entire stroke or a ministroke constituting aportion of the entire stroke.

What have been described are single pass methods for compressingstrokes. A second compression pass can be applied to the compressedstrokes, thus obtaining greater compression at the cost of additionalcompute time. In the examples shown, the repeating patterns ofdirectional change can be compressed, using any of a variety of knownpattern compression techniques. The program would determine whether anyadditional compression passes would be warranted.

Returning to the original task of describing how strokes are processedand stored in the software system, let us review what has been covered:

--Mapping a stroke on the screen to a document line;

--Determining the line relative coordinates of the stroke within thedocument line; and

--Compressing the stroke.

What remains is a description of the approach used to store strokeswithin the document line data structure.

A document line consists of two distinct writing areas--the lined areaand the unlined or margin areas. Within the margin areas, word wrappingis not supported; as such, strokes need merely be appended to a growinglist of strokes associated with the document line. That is, the strokesare ordered by time.

Strokes within the lined area are stored differently due to the wordwrapping nature of the lined area. See the discussion below on BreakPoint Gap Analysis: The Leftmost Positioning Method for details of thestroke ordering and storage.

Representation of ASCII characters in a Format Compatible with Strokes

Binary encoded characters (e.g. ASCII characters) by definition aregraphically defined elsewhere. There is no need for the processor toduplicate this information by storing it in a compressed stroke orbitmap format within the data structures comprising a line. The piecesof information that the processor needs in order for it to representASCII characters in a format compatible with strokes are:

--The ASCII character code;

--The position of the ASCII character within the document window;

--Font and point size information.

The position of the ASCII character is determined by the processor usingstandard text spacing algorithms for downloaded ASCII text. For ASCIItext that resulted from the translation of script, the processorreplaces the script with ASCII text as the translation takes place. Thistypically results in a shrinkage of the script since the ASCII textcharacters will usually be smaller than the script characters and theuser normally requests that consistent and standard spacing existbetween characters within a word and between words within a sentence.

The position of the ASCII character, its font, and its point size areused to determine the character's starting point (origin), left-mostpoint, and right-most point positions relative to the lined areabeginning points along the left margin. This is the same sort ofinformation that is maintained for strokes. Because strokes, ASCIIcharacters and bitmapped images are ordered by left-most point position,ASCII characters can be interleaved with strokes within the processordata structures, allowing the mixed data types. The processor must beaware of the distinction between data types when it must display thedata. The stroke visual data will be derived from the compressed strokesand the ASCII character image will be extracted from a table addressedby ASCII character code.

FIG. 9 shows that an "o" could exist in a pen-based system according tothe invention as a stroke, an ASCII character, or a bitmap. At thesimplest level, data within the system exists as a series of glyphs,each having a starting point (origin), a left-most point position, and aright-most point position. The starting point (origin) is used toposition the glyph within the line space. Since the left-most andright-most point positions are encoded relative to the starting pointposition, they are automatically moved whenever the starting pointposition is moved, i.e., the stroke/character is shifted left/right. Theleft-most and right-most point positions are used to determine thebreakpoints within a line (the word boundaries) as described above. Theonly time that the processor is (and needs to be) aware of the specifictype of glyph (stroke, ASCII, or bitmap) is when it stores the glyph,when it determines word boundaries, and when it displays the glyph. Atthese times, glyph-specific data is required. Note in FIG. 9 that thestarting point is not really glyph-specific even though it varies withglyph type. It still represents the anchor position for all glyphs andamong all glyph types it is the point that moves.

In FIG. 9, all glyph types have the same left-most and right-most pointpositions (1 and 6 respectively). For purposes of determining wordboundaries and word wrapping, these are the important variables.

Break Point Gap Analysis: The Left-most Positioning Method

In both hand printed and typed (or computer processed) documents, wordsare separated by a larger amount of space than that which separatescharacters within a word. The larger amount of spacing between words isthe basis on which the invention determines word breaks, andaccordingly, word wrap.

The invention employs a novel method for determining stroke-characterword breaks. This method is referred to as the Left-most PositioningMethod (LPM). LPM orders stroke images within a given line according totheir left-most point position. Once a text line has been detected, LPMrelies exclusively on a single axis for acquiring stroke positioningdata. Therefore, strokes are ordered left to right in a stroke database.The time order of strokes entered can be maintained by time-stamping thestrokes.

The Break Point Gap (BPG) value is predetermined at the outset of strokeposition data capture. The BPG is calculated as a predetermined twodimensional area of points (a parallelogram such as a rectangle). Forhighly slanted text, a user-modifiable angle for the parallelogram canbe determined from the user's writing.

As stroke data is captured, LPM relies on the BPG value for determininga word break. LPM performs a comparison between the (white space) valueof the space between the right-most point position of the precedingstroke data, and the left-most point position of the current strokedata, with the BPG value. If the white space value is greater than orequal to the BPG value, then the LPM has detected a word break.Accordingly, LPM inserts a break point marker B (see FIG. 5B) at alocation adjacent to the left-most point of the current stroke data.

Word Wrapping: Employing the Break Point Marker

Word wrapping is the process of filling lines of text and/or script andmoving text/script that overflows the line space contents automaticallyto the succeeding line space. Word wrap is not mandatory until atext/script manipulation event occurs. When the system detects atext/script manipulation event, then word wrapping is invoked.

The word wrapping detection method involves "reflowing" the text/scriptacross line breaks. This is preferably done by comparing locations ofbreak point markers (B in FIG. 5) with line delimiters (beginning andending points 36, 38). If a stroke is detected as crossing the addressof a line delimiter (or margin boundary), a word wrap is required. Towrap, the system parses backward searching for the last break pointmarker. Upon finding said marker, the system moves all text immediatelyfollowing the marker to the succeeding line, and recursively applies thecheck for a margin boundary violation and again wraps the text/scriptuntil all text/script has been reflowed within the lines such that nostrokes violate a margin boundary.

An alternative implementation would function as follows: Stroke datawould continue to be added to the database, while the system comparesthe amount of data captured with the amount of line space allocated. Assoon as stroke data is captured which, if placed on the current line,would exceed the margin boundary, a word wrap would be required. Theactual wrapping would be triggered by some event or action thatindicated the user had finished writing on the line. To wrap, the systemwould employ the recursive process described above.

WrapGap Analysis: The WrapGap Monitoring Method

Another of the many problems addressed by the invention involvesmaintenance of designated space between words. When editing script text,a means is required for adding and/or deleting white space toaccommodate additional stroke data (more handscribed text).

To facilitate managing the white space between words, a variable calledWrapGap is maintained that records the amount of white space between theleft-most point of the first stroke of a word on a line and theright-most point of all strokes composing words on the preceding line,whenever the current line is viewed as an extension of the precedingline (i.e., no intervening BOL). By default, each line is assigned aWrapGap value that is equal to the BPG value. When word wrapping forwardoccurs, the WrapGap value shown graphically in FIG. 5B indicates theamount of space that must exist between the right-most point of thefirst word wrapping to a line and the left-most point of the first wordcurrently on that line. The WrapGap must then be changed to reflect thespacing between the left-most point of the left-most wrapped word on aline and the right-most point of its former neighboring word on thepreceding line. When the user deletes space or strokes, causing words towrap backwards, the WrapGap value indicates the amount of space thatmust exist between the right-most point of the last word on the linewhere words will be wrapped back to and the left-most point of the firstword that will wrap back to that line. The WrapGap must then be changedto reflect the amount of space between the right-most point of the lastword wrapped back to a line, and the left-most point of the newlypositioned first word on the succeeding line (where the words wrappedfrom originally).

Another common case in which this feature is apparent is when changingline lengths (side margin widths). This case is shown in FIG. 5B, inwhich a line of script is shortened in successive steps and thenreturned to its original length. There are two additional cases wherethe WrapGap value can be modified.

Whenever a word wraps, a new WrapGap value for the line is computed. Inthe first case, a word may wrap because a significant amount of space isallocated preceding the word. Subsequently, a new word may be added onthe preceding line within the previously allocated white space.Therefore, the actual (desired) space or gap between the word beginningon the subsequent line and the word on the preceding line, has changed.This value is no longer the original value allocated between the lastright-most point position of a preceding word and the left-most pointposition of the wrapped word. Rather, it should now be the value betweenthe right-most point position of the added word and the left-most pointposition of the wrapped word. In this way, if a margin is subsequentlyincreased, and/or some other editing function forces the wrapped word toreturn to the preceding line, or the added word to wrap onto thesubsequent line, the actual space between the added word and theoriginally wrapped word will be properly maintained because the WrapGapvalue has been updated to reflect the modification. The user will havethe option of disabling this WrapGap adjustment feature.

Another case for WrapGap value modification occurs when the user employsa "delete-space" gesture (refer to the discussion on "Gesture-BasedEditing" below) following all strokes on a line space. With thisgesture, the user causes words from the next line space to wrap back tothe current line space. If there is a "Beginning of Line" (BOL) markeron the next line space, it will be removed. The system then determineswhether the space consumed by the first word on the next line plus thebreak point gap (BPG) value represents an amount of space less than orequal to the open space available at the end of the line where thegesture was made. If so, then the system detects that at least one wordcan be wrapped-back and, therefore, proceeds to reduce the WrapGap forthat word only enough (if at all) to ensure that such word will wrapbackwards (e.g., return to the preceding line space.)

A variation on this method would use the pen-up X-coordinate position ofthe Delete-Space gesture as the target position (or location) to whichthe left-most point of the first wrapped-back word should be "anchored."In such case, the WrapGap value for the first word to be wrapped backcould be ignored. Only the space consumed by the strokes at the firstword would be considered in determining whether the word can be wrappedback. If the word will fit within the space existing between the pen-uplocation and the right margin, the WrapGap value for the first wordeffectively becomes equivalent to the space existing between theright-most point of all strokes on the wrap-back line and the pen-uplocation.

EXAMPLE 3

FIGS. 7A through 7U show a series of screen displays for an operativeexample of the invention as implemented in a computer system arranged asin FIG. 1 with a stylus and contact and proximity-sensitive digitizer asthe graphics input device. The document display is shown on aconventional graphics CRT monitor and the computer is a conventionalIntel 386-based personal computer. The following figures show a basicsubset of the operations that can be performed on a document display inaccordance with the invention. This example shows the interactivemanipulation of printed script, cursive script and small sketches withinthe lined area of the document display, and of drawings and scriptwithin the unlined or drawing areas and margins of the display. Althoughnot shown in this example, ASCII text placed in the lined area will behandled and will behave during manipulation in essentially the samemanner as script, and can be considered as represented in this exampleby the printed script.

FIG. 7A is a view of an initial screen display in which printed andcursive script have been manually entered by writing on the digitizerwith a stylus. The document display 30 itself includes a top displaymargin, bounded by a pair of closely-spaced lines, containing title andcommand or menu lines. All actions in these areas are treated ascommands and do not result in the entry of script. Besides, or insteadof menu titles "edit" and "services," the command line can include icons(not shown). Below the double line is the display document itself, whichis organized in pages.

As shown in FIG. 7 and 7A, the default structure of each page of thedisplay has a series of parallel horizontal lines 34, each havingvertically aligned beginning points 36 and end points 38. The linesthemselves each define line spaces 39 of equal vertical width. Thebeginning and end points of the lines are spaced inward from the sidesof the display to define the lengths of the lines (which can be varied)and width of left and right margins 40, 42 (which are likewisevariable). The first line is spaced three line spaces below the top ofthe document display space defined by the double line. The spacing ofthe first line below the double line is sufficient to provide a singleline space above the first line into which script or text can be enteredand two additional linespace widths to serve as a top margin 44. Abottom margin 46 having a width of two line spaces is also provided. Thetop and bottom margins 44, 46 are treated as unlined space in the samemanner as the left and right margins 40, 42. The top, bottom and leftand right margins define an unlined drawing area which surrounds thelined script area. The margin areas can be slightly shaded to helpdistinguish them from the script lines.

Referring to FIG. 7B, the "insert space" gesture command has beenperformed in the first line of the script, immediately after the printedscript. This was done by placing the cursor between the printed scriptand the first word of the cursive script, holding the stylus momentarilyin one place in contact with the digitizer surface; then moving thestylus tip rightward to an end point spaced inward from the ending pointof the line, and lifting the stylus. This action has opened a length ofline space defined by the length of the gesture in the first line. Thecomputer document display has also responded to this action by pushingthe script to the right of the insert point of the gesture toward theright in the first line, wrapping down into the second line andrightward in each successive line. After completion and execution of theinsert space gesture, the user drew/wrote a large dot with arightward-directed arrow, followed by the words "Insert Space Gesture"in printed script, into the space that had been opened by the gesture.

FIG. 7C shows editing of the text inserted in FIG. 7B. This is done byperforming a "delete space" gesture, commencing after the word "insert"in FIG. 7B and extending leftward to the beginning of the arrow shown inFIG. 7B. This was followed by an "insert space" gesture to reopen spacethat the "delete space" gesture consumed. Then, a leftward-directedarrow was drawn in place of the rightward-directed arrow and the word"delete" was written where "insert" previously appeared.

Operation of the delete space gesture is further illustrated in FIG. 7D.When this gesture, or any gesture is performed, placing and momentarilyholding the stylus in place on the digitizer causes the display to showa filled circle at the pen down location (after "gesture" in line 1).The filled circle serves as a "gesture prompt" to provide feedback tothe user that the input device is now operative in the gesture mode. Assoon as this gesture prompt is displayed, the user then drags the stylusleftward along the line space to be closed. The version of softwareoperated in the present example actually draws a line through the spaceto be closed (and across the text to be deleted). This illustrates theprinciple of the two-part gesture prompt/gesture command structure, butdisplay of the gesture is not essential. Alternatively, the command canbe executed as the gesture is being made, as soon as the gesture'sdirection is determined. After executing the delete space gesture, thesystem closed the line space between the gesture prompt and the endpoint of the gesture, obliterating the text contained in the line spacebetween such points. A variation on the Delete Space gesture has thestrokes following the gesture on the line (if any) being left-justifiedat the pen up position for the gesture. Another variation has thestrokes following the gesture on the line (if any) being left-justifiedat the left-most point position of any deleted strokes (i.e., thefollowing strokes take the place of the deleted strokes). Thesevariations enable easy maintenance of word spacing.

FIG. 7E shows the operation of the "insert BOL marker" gesture and itscorresponding editing function. This editing gesture and function wasperformed after the word "script" in line 1. It has the effect of addinga beginning of line (BOL) marker at the insert location, that is, at thelocation where a gesture prompt appears upon commencement of thegesture, and then moving the affected text to the beginning (leftmargin) of the next line. Actually, all text on the line following thegesture prompt position is wrapped forward to the next line, that linethen being prefixed with a beginning of line (BOL) marker. As the usercontinues to move the stylus downward across additional lines, theaffected text moves with the stylus, leaving BOL-marked blank lines tofill the gap created by moving the text downward within the document.This can be seen by comparing FIGS. 7D and 7E.

FIG. 7F shows the same line, after doing a sketch of the gesture and abrief description of the gesture's function.

FIG. 7G illustrates what will be done to close the added line. As theedited display of FIG. 7G states, the user executes a delete linecontents gesture by placing the stylus on the point of the digitizercorresponding to a point on the second line of the display and, afterreceiving the gesture prompt, moves the stylus upward toward the firstline.

FIG. 7H shows the screen display after execution of the delete linecontents function. The third line of script is moved up into the secondline, obliterating the script contents of the second line, and isfollowed by an upward shift of the contents of each subsequent linespace. This editing function can be used on multiple lines of text.

As mentioned above, the document display preferably includes multiplepages. The pages are not isolated from one another, however, but permitscript to be moved freely back and forth across page break boundaries.This is shown in FIG. 7I. To illustrate the point, thepreviously-entered script has been shifted downward (using the insertblank line function) to the bottom of the first page. Then, an insertmoving space gesture was carried out in the third line of scriptimmediately preceding the word "principles" to cause the last few wordsof script to word wrap off the end of the last line of the first page.In word wrapping, these words were pushed over the bottom margin, pagebreak and top margin onto the first line of page 2 of the documentdisplay.

FIG. 7J shows the effect of entering additional script commencing at thepoint of the insert moving space gesture in the third line of script onpage 1. The user has entered additional printed script, much as onewould do in editing a document. Rather than filling a space of fixedlength, however, using the insert moving space function causes spacecontinually to be added to the lines ahead of the user's entry ofscript. Thus, the user has entered nearly two lines of script, extendingover the page break onto the first line of page 2. Note that a length ofopen line space remains immediately preceding the word "principles,"which space is the moving space defined by this function. Thus, themoving space as well as the text downstream from it is wrapped not onlyaround ends of lines but across page breaks and margins. In doing so,the contents of the margins (none shown) are unaffected.

FIG. 7K shows closure or collapsing of the moving space, accomplished inthe current implementation by attempting any gesture, including anotherinsert moving space gesture.

When a moving space is collapsed, the spacing between the left-mostpoint of the strokes following the moving space and the right-most pointof the added strokes will be the space that existed between the initialstrokes that were separated by the moving space. This means that if thespace is opened within a word the open moving space will be collapsed toa smaller whitespace gap than if the space had been opened betweenwords.

A variation on the moving space concept has the moving space sensitiveto proximity. After moving space has been opened with the Insert MovingSpace gesture, the moving space would collapse on pen-out-of-proximityand reopen on pen-in-proximity. This would allow the user to makemultiple edits using moving space without having to explicitly open andclose the moving space. When the moving space reopens, the position ofthe moving space within the text would reflect the position of thestylus in proximity. In this way the user could move the stylus aroundto preview various insert positions within words or lines. When pen downoccurs, the moving space would shift according to the user's enteredstrokes. The Collapse Moving Space gesture (same as Insert Moving Spacegesture) would end this process.

Another variation on the moving space gesture has the action of movingthe pen to a vertical orientation causing a Moving Space Gesture prompt.The prompt would be an open space that would move with the pen(pen-in-proximity but not touching) as the user previewed moving spaceinsertion positions within text. (The user need not hold the penvertical once the prompt appears.) Pen-down would be the gesture thatactually created a moving space. Until pen-down, insert positions wouldbe previewed at varying degrees of resolution. Fast pen movement wouldpreview insert positions between words and slow pen movement (overwords) would preview insert positions within words. Returning the pen tothe vertical position (after having been not vertical) would cause themoving space to be collapsed. If the pen tip had not been within (over)the moving space when the pen was positioned vertically then a newmoving space would preview at the pen position.

As mentioned above, drawings can also be included in unlined areas ofthe document display and are not affected by editing functions performedon the contents of the lined area. To illustrate this point, FIG. 7Lshows the previously-entered script moved back to the top of page 1. The"services" menu item has been invoked, followed by selection of the"insert ruler" command. FIG. 7L shows use of this command to cause tworulers to be drawn across the document display at about mid-screen. Therulers are shown as black horizontal bands across the document display.The final version of the product will have rulers containing graphicsdepicting the current margin settings. The top ruler is always present(although it may be hidden) and contains margin settings which can beset by the user wider or narrower than the default margins. The lowertwo rulers are placed by the user at locations designated by contactingthe stylus to the digitizer at user-selected points.

Next, referring to FIG. 7M, using the stylus, the user selects a newline length within the area defined vertically between the lower tworulers. In the present software version, the user affirmatively selectsthe line length by drawing a gesture on the ruler from the left orbeginning point of the line to a desired end point of the line. Thisprocedure could be reversed, to define the margin or drawing area widthbetween the rulers. Alternatively, an icon representative of thisfunction could be provided which the user selects and simply draws aline vertically from top to bottom at a desired location along the linesto define the height and width of the lined space (or conversely theunlined space). This approach would automatically insert and positionrulers where the user starts and stops the vertical line.

Reinvoking the "services" menu and selecting "hide rulers," leaves thedocument display of FIG. 7N. To illustrate subsequent points, the userhas drawn a diagram of a pen-based computer in the unlined drawing areaand has labeled the diagram "pen-based computer."

FIG. 70 shows the document display of FIG. 7N as the user makes a deletespace gesture across some of the script in the second line of thedisplay.

FIG. 7P shows the display after execution of the delete space function.This causes the contents of subsequent lines to word wrap or reflowupward to fill in the space occupied by the deleted line space contents.Note that reflow of the line contents has no effect at all on thedrawing and script labeling within the unlined drawing area. Asmentioned above, the gesture commands are context sensitive, dependenton where they are located, and will cause different things to happen iflocated in the unlined area than if located in the lined area.

FIG. 7Q shows an "insert lines" gesture performed in the left margin,and its effect which was to add three lines following line 2 of thedocument of FIG. 7P. Comparing FIG. 7Q with FIG. 7P, it should be notedthat this command actually added more lines between the previouslyexisting lines, rather than merely shifting the contents of lines 3, 4and 5 downward. The result of this function was to shift the contents ofboth the lined area and unlined area below line 2 downward as a unit.

FIG. 7R contrasts the two functions performed by the insert linesgesture dependent upon where such gesture is performed. In FIG. 7R, theuser has performed the insert lines (actually "insert BOL marker")gesture within the script in one of the lines alongside the drawing. Thefunction corresponding to this gesture command is, as described above,to push the line space contents downstream of the pen down location ofthe gesture onto subsequent lines without moving or otherwise affectingthe drawing. Note also that, during word wrapping, the software comparesthe length of words to the amount of space available in each line todetermine whether there is sufficient space for the word. Thus, the word"character" in FIG. 7Q was too long to fit on the preceding linecontaining the word "unique." Similarly, in FIG. 7R, the word "unique"was too long to fit in the remaining space of the preceding line.

FIG. 7S shows the context sensitive nature of the delete lines gesture.This gesture was performed in both the lined area on the line precedingthe word "operation" as indicated by the sketched arrow at thatlocation, and in the unlined left margin at the location indicated bythe upward-directed arrow in the margin. The delete lines gestureperformed in the lined area shifted the script contents upward by oneline, obliterating the words "gesture (lines)" and the downstream scriptor line contents reflowed upward to fill in the space left by theobliterated line contents. The delete lines gesture performed in themargin shifted all of the lines and the unlined drawing area upward byone line without any reflow of the document. If there had been anycontents in the deleted line, these would have been deleted.

FIG. 7T shows the display after reinvoking the services menu, showingthe rulers where they had previously been placed and collapsing thelines alongside the drawing area (that had previously been designated)to a length essentially equal to zero (actually one pixel in length withthe beginning and end points of each line set equal). This functioncould also be incorporated into an icon. Upon removal of the rulers, thedocument appears as shown in FIG. 7U. Note that when the lines alongsidethe unlined drawing area were shortened, the contents of the line spaceswrapped downward to the first and subsequent lines below the drawingspace. If space or script were added to the lines immediately precedingthe drawing, for example, by using an insert moving space gesture, wordsfrom these lines would wrap across the drawing area to the lines below.

The foregoing summarizes the principal features of the gesture sets andtheir corresponding editing functions. As demonstrated above, thesegestures can be used in various combinations to achieve differentediting results. Other gestures and their corresponding functions arelikewise operative in a consistent manner although not demonstrated inthe foregoing example.

Fast Data Entry Using a Pen

The following describes how to provide pen-based computers with a methodfor fast and accurate text entry. Currently, pen-based computers allowthe user to print characters and words which are then recognized by thecomputer. Some pen-based systems allow the user to hunt for characterson the image of a keyboard displayed on the screen. Neither of thesemethods is particularly fast or accurate--a printed character can bemis-recognized or a word can be misspelled. The method next describedcan be used with any computer that employs a pointing device. Thepointing device is used to choose among a set of characters presented tothe user.

The basic idea revolves around the fact that as each letter of a word isspecified, the possible range of succeeding letters is narrowed in amanner determined probabilistically in the user's language (e.g.,written English). Following an initial letter selection by the user, themost probable next character is presented to the user at a positioncloser to the pointing device than other characters available forconstructing words. This allows the user to move the pointing device theshortest distance in order to specify the characters of a word. It alsoassures that the user ends up with a correctly spelled word because onlythose character sequences that spell words are presented to the user. Anexample is shown in FIG. 10. The initial range of characters ispresented to the user in alphabetical order.

The user wants to spell "zoom" so "z" is touched with the pen, at whichtime the characters "n a e i o u y w" were presented, representing themost probable letters following an initial "z" in English words. Thesecharacters are arranged so that the most probable choices are closest tothe initial "z." The user then touches the letter "o," at which time thecharacters "d m r o u n" are presented. Again these characters arearranged so that the most probable choices are closest to the lastchoice, "o." The user then touches the letter "o" in the latest set ofcharacters and is presented with "zoology zoom zoomlens zoophyte."Rather than another set of characters, the user is provided with theentire set of words that exist containing the character sequence thathas been specified so far. The user has already specified the word "zoo"by touching characters, but since the word "zoom" was desired, the usercompletes the word by touching the word "zoom." Since the pen has beentouching the "paper" for the entire duration of the word specification,the user merely lifts the pen in order for the word to be appended tothe line of text that he is creating. The user can now repeat theprocess to find (get) another word. If, during the word specificationprocess, the user finds that he made a mistake (was heading in the wrongdirection due to a bad preceding character selection), he can backtrackwith the pen to undo preceding character selections.

The set of words available to the user when using this data entryapproach can vary. For instance, the set of words could be restricted tochemical names in certain applications. Additionally, the positioning ofcharacters following the initial character selection could change as thesystem learned the user's preferences for certain words. A simpleimplementation of this learning might be to switch the position of eachcharacter selection with its higher probability neighbor. Then, the moreoften a certain character is used, the closer it is positioned to thepreceding character selection. If the user wants to enter a word that isnot in the current dictionary (set) of words, that word could be spelledby tapping in the proper sequence of the word's characters on theinitial alphabet line.

DETAILED DESCRIPTION OF MOVING SPACE PROCESSING

In the following description `glyphs` should be interpreted as meaningstrokes and/or ASCII characters and/or bitmaps.

Moving Space is an open (blank) area for data entry that shifts forwardalong a line as the user enters data. When all remaining space on a lineis clear for data entry, a new moving space is opened at the beginningof the next line. This process can be used to open added writing spacebetween words, within words, and even within blank lines. Oncecommenced, this process continues until the user performs some explicitaction (e.g. Collapse Moving Space Gesture), or another gesture thatreformats the text, at which time the moving space is collapsed. Thisprocess is described more fully below with reference to FIGS. 11A-11E.

FIG. 11A shows an initial glyph spacing 70 existing before the InsertMoving Space Gesture is used. The user makes this gesture at auser-selected location in a line of glyphs to specify the startingposition 72 for the moving space and initiate the Insert Moving Spacefunction.

FIG. 11B shows inserted moving space having a left x position 78, aright x position 82, a moving space width 76, and a trigger point 80specified by a trigger point offset 74.

FIG. 11C shows the moving space after the word `or` was written in it.Notice that a portion of the letter `r` crossed the trigger point 80.

FIG. 11D shows the moving space after it has shifted right due to thetrigger point 80 in FIG. 11C having been crossed. Notice that a new leftx position 78A exists at the point where the pen was detected crossingthe trigger point. A new trigger point 80A and right x position 82A alsoexist that are relative to the new left x position 78A.

FIG. 11E shows the line of script after the moving space has beencollapsed by a Collapse Moving Space Gesture. Note that the moving spacewas collapsed down to the initial stroke (word) spacing &70) thatpreceded the word `ASCII` in FIG. 11A.

Following is a brief description of a set of subroutines, contained in acombination pseudo-code and structured English description in APPENDICESA-D, that implement various steps of the Moving Space Processing. Inthis description of the process, it is assume that glyphs are orderedwithin a line by their leftmost point position and that word wrapping ispropagated through the document when the process is initiated. Beforedescribing the subroutines, following are definitions of the variablesused throughout.

    ______________________________________                                        Moving Space Processing Variable Definitions                                  ______________________________________                                        MOVINGSPACELINE: The number of the document line                                               (DL - See Conversion of Strokes,                                              above) containing the moving                                                  space.                                                       MOVINGSPACEACTIVE:                                                                             Flag indicating whether moving                                                space is currently active.                                   MOVINGSPACELEFTX:                                                                              The left-most x position 78 of the                                            moving space 76; initially point                                              72 in FIG. 11A.                                              MOVINGSPACERIGHTX:                                                                             The right-most x position 82                                                  (FIGS> 11B-11D) of the                                                        moving space 76.                                             TRIGGERPOINT:    The x position 80 (FIGS.                                                      11B-11D) that, when crossed by                                                the pen, will cause more moving                                               space to be opened up. The                                                    TRIGGERPOINT controls the                                                     amount of input that can be                                                   received within the moving                                                    space before processing occurs to                                             open up additional moving space.                                              Since opening up moving space                                                 consumes a lot of time and results                                            in a visual adjustment of data, the                                           TRIGGERPOINT allows for                                                       the fine tuning of space opening                                              so that the user is presented with                                            the most pleasing moving space.                              TRIGGERPOINTOFFSET:                                                                            Offset 74 (FIGS. 11B and 11D)                                                 from the                                                                      MOVINGSPACELEFTX for                                                          the TRIGGERPOINT.                                                             A separate TRIGGERPOINT                                                       OFFSET can exist for moving                                                   space initially opened within a                                               word as opposed to moving                                                     space opened outside of a word.                                               This value can be adjusted by the                                             user, with a preferred default                                                value and range established as                                                follows:                                                                      Default value: Determined by                                                  software developer through user                                               testing.                                                                      Range: 0 <=                                                                   TRIGGERPOINTOFFSET <                                                          MOVINGSPACEWIDTH                                             MOVINGSPACEWIDTH:                                                                              The width 76 (FIGS. 11B and                                                   11D) corresponding to the num-                                                ber of data points contained                                                  within the moving space. A sep-                                               arate MOVINGSPACEWIDTH                                                        can exist for moving space                                                    initially opened within a word as                                             opposed to outside of a word.                                                 This value can be adjusted by the                                             user but should remain at least as                                            large as the                                                                  BREAKPOINTGAP.                                                                Default value: user adjustable,                                               e.g., 1 inch                                                                  The MOVINGSPACEWIDTH                                                          should be large enough so that                                                the user will not be able fill the                                            moving space with writing before                                              the system has a chance to                                                    process the pen move events and                                               open up additional space.                                                     Otherwise, the user might get                                                 the impression that ink dribbled                                              beyond the moving space and                                                   over existing glyphs is over-                                                 writing the existing glyphs, which                                            it is not. When the system catches                                            up with the user, the user will                                               see that the new writing and                                                  preexisting glyphs are separated                                              by moving space.                                             INITIALGLYPHSPACING:                                                                           The amount of space 70 that                                                   existed between glyphs before                                                 the moving space separated them.                                              Range: 0 <=                                                                   INITIALGLYPHSPACING                                          SPLITSTROKES:    User settable flag that indicates                                             whether a stroke that crosses the                                             starting position 72 specified                                                during opening of moving space                                                or during space insertion can be                                              divided into multiple strokes.                               MOVINGSPACETYPE: A value indicating whether the                                                moving space was initilly opened                                              within a word or outside of                                                   a word.                                                      AUTOSCROLL:      Contains the line number (DL)                                                 of the document line that needs                                               to be scrolled onto the screen                                                for display.                                                 WRAPGAP:         Maintains a value indicating the                                              spacing between words for                                                     word wrapping.                                               BREAKPOINTGAP:   The amount of space that must                                                 exist between glyphs in order                                                 for a word boundary to be                                                     recognized.                                                  ______________________________________                                    

Description of Subroutines

The subroutine described in APPENDIX A is a shared routine that is usedin a number of other subroutines. It opens moving space at the beginningof a document line succeeding a current MOVINGSPACELINE. It causes thesucceeding document line to become the current MOVINGSPACELINE, and thenreturns to the calling routine.

The Insert Moving Space Procedure described in APPENDIX B is invokedwhen the user makes an Insert Moving Space gesture (FIG. 4F). Thissubroutine tests the location (72) at which the user has asserted theInsert Moving Space command to determine whether it is within a glyph(e.g., a script word), between glyphs as shown in FIG. 11A, or on a linewhich has no glyphs to the right of point 72. In the first case, thesubroutine determines whether point 72 intersects any strokes, and if soit splits and saves the intersected stroke(s). In the second case, thesubroutine determines that point 72 is between glyphs, and saves theinitial glyph spacing 70 at that point as the variableINITIALGLYPHSPACING for restoration when the Collapse Moving SpaceProcedure, described below, is invoked. In the third case, when thereare no glyphs on the current line to the right of the insertion point72, the routine searches succeeding lines, so long as a BOL marker isnot encountered, to find the next glyph and establish a WRAPGAP spacingas the INITIALGLYPHSPACING, and otherwise to establish the BREAKPOINTGAPas the INITIALGLYPHSPACING. Once this is done, the subroutine sets upthe moving space, including establishing the MOVINGSPACELEFTX,TRIGGERPOINT, MOVINGSPACERIGHTX locations; shifting the glyphs to theright of the insert point 72 rightward and wordwrapping as necessary;and redisplaying the rearranged data with the inserted space. The amountor width 76 of inserted space is determined by the MOVINGSPACEWIDTH setby the user for the particular MOVINGSPACETYPE. The TRIGGERPOINTOFFSET74 is likewise set by the user. In each case, default values can be set.

The Pen Down/Pen Moved Event procedure is implemented in the subroutinein APPENDIX C. This procedure, which is diagrammed in part in FIG. 3C,drives the moving space propagation. Whenever the stylus crossesrightward over the TRIGGERPOINT 80 (See FIG. 11C), this procedureessentially shifts the moving space rightward, shifting any glyphslocated to the right of the moving space rightward along the currentline and wrapping them down to a succeeding line when the right marginof the current line would be exceeded, as previously described. Then,the user can enter script in the moving space beginning at the user'scustomary spacing from the last glyph preceding the space. As the userwrites in the space, the added script is displayed. When the scriptcrosses the trigger point 80, this subroutine causes the computer anddocument display to supplement the added space and update the display.The trigger point and moving space width are preferably set so that theuser can write for a comfortable distance without overwriting the glyphsat the end of the moving space and without having to update the displaytoo often.

APPENDIX D describes an implementation of a Double Tap Event, which theuser invokes while the moving space is active by tapping the stylustwice in a brief period of time in substantially the same location onthe digitizer. There are certain instances when the user might wantmoving space propagation to continue without the user having to enterdata (strokes) within the moving space in order to drive thepropagation. One instance might be at the end of a line when the userknows a word would not fit in the space remaining on the line (includingthe space currently occupied by words that would be wrapped forward) butwants the moving space to propagate and move onto the next line. Theuser need merely double tap at a position to the right of theTRIGGERPOINT where it is desired that the next MOVINGSPACELEFTX beplaced. The moving space will move and no data (strokes) will resultfrom the double tap.

The Collapse Moving Space Procedure, shown in APPENDIX E, is invokedwhen the user again performs the gesture of FIG. 4F, to terminateexplicitly the Insert Moving Space mode, or terminates such modeimplicitly by invoking a reformatting procedure. Note: It is notpossible for a stroke to begin to the left of the MOVINGSPACERIGHTX andpass over the MOVINGSPACERIGHTX because additional space will have beeninserted (and MOVINGSPACERIGHTX will have been shifted) preventing thestroke from ever crossing the MOVINGSPACERIGHTX. Hence, any glyphscommencing to the right of MOVINGSPACERIGHTX are presumed to bepre-existing script, text or bitmapped images, and are shiftedaccordingly as the initial glyph spacing 70 is restored upon collapsingthe moving space.

An alternative to the specific implementation disclosed in theAppendices is a multi-tasking implementation of moving space. Themulti-tasking implementation of moving space can be viewed as having twotasks. The first and highest priority task provides for dynamic movingspace insertion and moving space line redisplay. The second taskreceives information from the first task concerning words that have beenshifted over the MOVINGSPACELINE right margin. The second task bundlesand wraps words forward to succeeding lines, redisplaying those linesthat are currently on-screen and have been changed by the word wrapping.

Having described and illustrated the principles of the invention in apreferred embodiment thereof, it should be apparent that the inventioncan be modified in arrangement and detail without departing from suchprinciples. I claim all modifications and variation coming within thespirit and scope of the following claims.

    ______________________________________                                        APPENDIX A: Shared Subroutine                                                 ______________________________________                                        Open.sub.-- Moving.sub.-- Space.sub.-- At.sub.-- Beginning.sub.--             Of.sub.-- Next.sub.-- Line:                                                   Find the first line following the MOVINGSPACELINE                             containing a lined area.                                                      If a line was found then                                                      MOVINGSPACELINE <-- document line number                                      of found line.                                                                If found line was marked with a Beginning Of Line                             (BOL) marker then                                                             Wrap forward the contents of the found line to                                succeeding line(s).                                                           Move the BOL marker to the succeeding line.                                   Endif                                                                         Else                                                                          Insert a line immediately following the                                       MOVINGSPACELINE that contains a lined area                                    (current implementation uses same margins as                                  MOVINGSPACELINE).                                                             MOVINGSPACELINE <-- document line                                             number of the inserted line.                                                  Endif                                                                         MOVINGSPACELEFTX <-- left margin position of                                   MOVINGSPACELINE.                                                             TRIGGERPOINT <-- MOVINGSPACELEFTX +                                            TRIGGERPOINTOFFSET.                                                          MOVINGSPACERIGHTX <--                                                          (MOVINGSPACELEFTX +                                                           MOVINGSPACEWIDTH) - 1.                                                       If MOVINGSPACERIGHTX exceeds the                                              MOVINGSPACELINE right margin then                                             MOVINGSPACERIGHTX <-- right margin                                             position for MOVINGSPACELINE                                                 Proportionately adjust the TRIGGERPOINT position                              within the compressed moving space.                                           Endif                                                                         Insert enough space at the beginning of the                                   MOVINGSPACELINE (by shifting any following                                    glyphs right) so that there is an open area of size                            (MOVINGSPACERIGHTX -                                                          MOVINGSPACELEFTX) + 1.                                                       Wrap forward to succeeding lines any words shifted over                       the right margin by the space insertion.                                      If the MOVINGSPACELINE is off-screen then                                     AUTOSCROLL <-- MOVINGSPACELINE                                                Else                                                                          Redisplay the MOVINGSPACELINE showing the                                     inserted moving space.                                                        Endif                                                                         Redisplay the lines following the MOVINGSPACELINE                             that are on-screen AND whose contents changed due                             to the word wrapping performed above.                                         Return to calling routine.                                                    ______________________________________                                    

    ______________________________________                                        APPENDIX B: Insert Moving Space Procedure                                     ______________________________________                                        If pen down occurred in a lined area then                                     If (a stroke on the pen down line has a left-most x                           position preceding the pen down x position AND a                              rightmost x position at or following the pen down x                           position (i.e. a stroke crosses the pen down x position))                     AND (SPLITSTROKES = true) then                                                Repeat for each stroke crossing the pen down x                                position:                                                                     Traverse the stroke until the pen down x position is                          reached, then split and save the stroke as 2 strokes.                         If the pen down x position was crossed from the left to                       the right then the first stroke will end to the left of                       the pen down x position and the second stroke will                            begin at the pen down x postion. If the pen down x                            position was crossed from the right to the left then                          the first stroke will end at the pen down x position                          and the second stroke will begin to the left of the pen                       down x position. Continue the traversal using the                             second stroke, repeating the split, save, and traverse                        process everytime the pen down x position is passed                           until no stroke data remains.                                                 Endif                                                                         Glyphs whose left-most x position is to the left of or at                     the pen down x position AND whose right-most x position is                    to the right of or at the pen down x position are                             considered to be at/following the pen down x position.                        If (the pen down line contains glyphs) AND (no glyphs                         exist to the left of the pen down x position) then                            INITIALGLYPHSPACING <-- WRAPGAP for pen                                       down line                                                                     MOVINGSPACETYPE <-- outside of word.                                          Else                                                                          If any glyphs on the pen down line are at/following                           the pen down x position then                                                  INITIALGLYPHSPACING <-- the distance between                                  the left-most point of the first glyph at/following the                       moving space insertion point (pen down x position) on the                     pen down line and the right-most x position of all                            glyphs preceding it on the line. Note that the                                INITIALGLYPHSPACING cannot be allowed to fall                                 below 0.                                                                      If INITIALGLYPHSPACING <--                                                     BREAKPOINTGAP then                                                            MOVINGSPACETYPE <-- within word.                                             Else                                                                           MOVINGSPACETYPE <-- outside of word.                                         Endif                                                                         Else                                                                          While no lines having a Beginning Of Line (BOL)                               marker are encountered, search for a succeeding line                          (SL) containing a glyph.                                                      If a non-BOL marked line (SL) containing a glyph was                          found then                                                                     INITIALGLYPHSPACING <-- WRAPGAP for SL.                                      Else                                                                           INITIALGLYPHSPACING <--                                                       BREAKPOINTGAP.                                                               Endif                                                                         MOVINGSPACETYPE <-- outside of word.                                          Endif                                                                         Endif                                                                         Use the TRIGGERPOINTOFFSET,                                                   MOVINGSPACEWIDTH                                                              corresponding to the MOVINGSPACETYPE.                                         MOVINGSPACEACTIVE <-- true.                                                   MOVINGSPACELEFTX <-- pen down x position.                                     TRIGGERPOINT <-- MOVINGSPACELEFTX +                                            TRIGGERPOINTOFFSET.                                                          MOVINGSPACERIGHTX <--                                                          (MOVINGSPACELEFTX +                                                           MOVINGSPACEWIDTH) - 1.                                                       MOVINGSPACELINE <-- pen down document                                         line number.                                                                  Shift the glyphs at/following the MOVINGSPACELEFTX                            (pen down x position) on the MOVINGSPACELINE to                               the right beyond the MOVINGSPACERIGHTX so that                                an open area of MOVINGSPACEWIDTH exists.                                      Traverse the glyphs on the MOVINGSPACELINE setting                            Breakpoints used for word wrapping.                                           Wrap forward to succeeding lines any words shifted over                       the right margin of the MOVINGSPACELINE.                                      Redisplay the MOVINGSPACELINE showing the inserted                            moving space.                                                                 If (the MOVINGSPACERIGHTX exceeds the                                         MOVINGSPACELINE right margin) OR (glyphs existed                              at/following the pen down x position but were all                             wrapped forward when the moving space was opened up)                          then                                                                          Perform.sub.-- Open.sub.-- Moving.sub.-- Space.sub.-- At.sub.--               Beginning.sub.-- Of.sub.-- Next.sub.-- Line.                                  Else                                                                          Redisplay the lines following the                                             MOVINGSPACELINE that are on-screen AND whose                                  contents changed due to the word wrapping                                     performed above.                                                              Endif                                                                         Endif                                                                         ______________________________________                                    

    ______________________________________                                        APPENDIX C: Pen Down/Pen Moved Event                                          ______________________________________                                        If MOVINGSPACEACTIVE then                                                     If the pen is on the MOVINGSPACELINE AND between                              the TRIGGERPOINT and MOVINGSPACERIGHTX (i.e.                                  if the pen is within the moving space and at or to the                        right of the TRIGGERPOINT) then                                               MOVINGSPACELEFTX <-- pen x location.                                          TRIGGERPOINT <-- MOVINGSPACELEFTX +                                            TRIGGERPOINTOFFSET.                                                          new MOVINGSPACERIGHTX <--                                                      (MOVINGSPACELEFTX +                                                           MOVINGSPACEWIDTH) - 1.                                                       Shift any glyphs following the old                                            MOVINGSPACERIGHTX to the right (beyond the new                                MOVINGSPACERIGHTX) in order to have a                                         MOVINGSPACEWIDTH quantity of space following                                  the pen x location (MOVINGSPACELEFTX).                                        Wrap forward to succeeding lines any words shifted                            over the MOVINGSPACELINE right margin.                                        Redisplay the MOVINGSPACELINE showing the                                     shifted moving space.                                                         If (the MOVINGSPACERIGHTX exceeds the                                         MOVINGSPACELINE right margin) OR (no glyphs                                   remain on the MOVINGSPACELINE following the                                   moving space) then                                                             Perform.sub.-- Open.sub.-- Moving.sub.-- Space.sub.-- At.sub.--               Beginning.sub.-- Of.sub.-- Next.sub.-- Line.                                 Else                                                                            Redisplay the lines following the                                            MOVINGSPACELINE that are on-screen AND                                       whose contents changed due to the wrapping                                    performed above.                                                              Endif                                                                         Endif                                                                         Endif                                                                         ______________________________________                                    

    ______________________________________                                        APPENDIX D: Double Tap Event                                                  ______________________________________                                        If MOVINGSPACEACTIVE then                                                     If the pen is on the MOVINGSPACELINE AND between                              the TRIGGERPOINT and MOVINGSPACERIGHTX then                                    MOVINGSPACELEFTX <-- double tap x location.                                   TRIGGERPOINT <-- MOVINGSPACELEFTX +                                            TRIGGERPOINTOFFSET.                                                          new MOVINGSPACERIGHTX <--                                                      (MOVINGSPACELEFTX +                                                           MOVINGSPACEWIDTH) - 1.                                                       Shift any glyphs following the old                                            MOVINGSPACERIGHTX to the right (beyond the                                    new MOVINGSPACERIGHTX) in order to have a                                     MOVINGSPACEWIDTH quantity of space following                                  the double tap x location (MOVINGSPACELEFTX).                                 Wrap forward to succeeding lines any words shifted                            over the MOVINGSPACELINE right margin.                                        Redisplay the MOVINGSPACELINE showing the shifted                             moving space.                                                                 If (the MOVINGSPACERIGHTX exceeds the                                         MOVINGSPACELINE right margin) OR (no glyphs                                   remain on the MOVINGSPACELINE following the                                   moving space) then                                                             Perform.sub.-- Open.sub.-- Moving.sub.-- Space.sub.-- At.sub.--               Beginning.sub.-- Of.sub.-- Next.sub.-- Line.                                Else                                                                           Redisplay the lines following the MOVINGSPACELINE                             that are on-screen AND whose contents changed due to                          the word wrapping performed above.                                           Endif                                                                          Endif                                                                        Endif                                                                         ______________________________________                                    

    ______________________________________                                        APPENDIX E: Collase Moving Space Gesture                                      ______________________________________                                        If MOVINGSPACEACTIVE then                                                     If a glyph having a right-most x position at or preceding                     the MOVINGSPACERIGHTX exists on the                                           MOVINGSPACELINE (i.e., if a glyph precedes or is within                       the moving space) then                                                        Find the right-most x position (RX) of all glyphs                             preceding or within the moving space.                                         If a glyph having a left-most x position following the                        MOVINGSPACERIGHTX exists on the                                               MOVINGSPACELINE (i.e. if a glyph follows the moving                           space) then                                                                    Find the left-most x position (LX) of all glyphs                              following the moving space.                                                   Adjust the space between RX and LX so that an amount of                       space equal to INITIALGLYPHSPACING exists.                                    The space adjustment is accomplished by shifting to                           the left (to decrease space) or the right (to increase space)                 the glyphs at and following LX on the                                         MOVINGSPACELINE.                                                              Traverse the glyphs on the MOVINGSPACELINE setting                            Breakpoints used for word wrapping.                                           If the space between RX and LX was increased then                            Wrap forward to succeeding lines any words shifted                            over the MOVINGSPACELINE right margin.                                         Else                                                                         Wrap backwards any words that will fit into the                               open space at the end of the MOVINGSPACELINE.                                  Endif                                                                        Else                                                                           While no lines having a BOL marker are                                        encountered, search for a succeeding line (SL)                                containing a glyph.                                                           If a non-BOL marked line (SL) containing a glyph                              was found then                                                               WRAPGAP for SL <-- INITIALGLYPHSPACING.                                       Wrap backwards any words that will fit into the                               open space at the end of the MOVINGSPACELINE.                                 Traverse the glyphs on the MOVINGSPACELINE                                    setting Breakponts used for word wrapping.                                     Endif                                                                        Endif                                                                         Else                                                                          If a glyph having a left-most x position following the                        MOVINGSPACERIGHTX exists on the                                               MOVINGSPACELINE (i.e. if a glyph follows the moving                           space) then                                                                    Find the left-most x position (LX) of all glyphs                              following the moving space.                                                   Position LX (the glyph containing LX) at the left                             margin shifting to the left all glyphs following it                           on the MOVINGSPACELINE.                                                      Endif                                                                         Wrap backwards any words that will fit into the open                          space at the end of the MOVINGSPACELINE.                                      WRAPGAP for MOVINGSPACELINE <--                                                 INITIALGLYPHSPACING.                                                        Wrap backwards any words that will fit into the open                          space existing at the end of the line preceding the                           MOVINGSPACELINE.                                                              If the INITIALGLYPHSPACING was less than the                                  BREAKPOINTGAP and glyphs preceding the moving space                           remain at the end of a first line and the glyphs                              following the moving space are on the second line                             because the combination of the two sets of glyphs will                        not fit on the first line, then the glyphs on the                             first line should be wrapped forward so that they can                         be joined with the glyphs on the second line.                                 Traverse the glyphs on the line preceding the                                 MOVINGSPACELINE setting Breakpoints used for                                  wordwrapping.                                                                 Endif                                                                         Redisplay the MOVINGSPACELINE and any lines that are                          on-screen whose contents have changed due to the above                        actions.                                                                      MOVINGSPACELINE <-- null.                                                     MOVINGSPACEACTIVE <-- false.                                                  Endif                                                                         ______________________________________                                    

I claim:
 1. A pen-based computer method for a user interactively to edita series of glyphs which include one or more of handwritten script, textor bitmapped images using a pen-type electrical input device on adynamic document display having a series of lines defining line spacesfor writing script, the method comprising:displaying the series ofglyphs on the document display along at least one of said lines;entering a first command using the input device in a predeterminedmanner at a user-determined location along a selected one of said linesto assert an insert moving space function, the computer and documentdisplay being responsive to open a predetermined amount added space atsaid location in the selected line including shifting any pre-existingglyphs on the selected line on one side of said location in a directionalong the line away from said location; entering one or more addedglyphs in the added space proceeding in said direction along the lineusing the input device, the computer and document display beingresponsive to the entry of the added glyphs to supplement the addedspace to approximate the amount of added glyphs; and entering a secondcommand to assert a collapse moving space function, the computer anddocument display being responsive to close the added space includingshifting the pre-existing glyphs on said one side of said location alongsaid line toward the added glyphs.
 2. A method according to claim 1including setting a triggerpoint at an offset defining a distance fromsaid location in said direction, the computer and document display beingresponsive to entry of an added glyph in said direction past thetriggerpoint to initiate supplementing of the added space.
 3. A methodaccording to claim 2 in which the offset distance is less than thepredetermined amount of added space.
 4. A method according to claim 2 inwhich said offset is set by the user.
 5. A method according to claim 2in which the predetermined amount of added space is set by the user. 6.A method according to claim 1 in which said location is positionedbetween adjacent first and second pre-existing glyphs having an initialglyph spacing, the computer being responsive to save said initial glyphspacing.
 7. A method according to claim 6 in which said computer isresponsive to the second command to restore said initial glyph spacingrelative to the added glyphs upon closing the added space.
 8. A methodaccording to claim 6 in which said computer is responsive to the secondcommand to reposition each part of the split stroke to adjoin oppositeends of the added glyphs upon closing the added space.
 9. A methodaccording to claim 1 in which said location is positioned within aselected pre-existing glyph so as to intersect a stroke defining aportion of the selected glyph, the computer being responsive to splitthe stroke and save each part thereof.
 10. A method according to claim 1in which said lines extend horizontally across the document display andthe direction in which glyphs are shifted in response to the firstcommand and script is entered using the input device in a rightwarddirection.
 11. A pen-based computer method for a user interactively toedit glyphs on a dynamic document display to insert handwritten scriptusing a pen-type electrical input device, the method comprising:forminga series of lines, each having a beginning point and an end point, todefine line spaces for writing script; entering glyphs, including one ormore of handwritten script, text or bitmapped images, along one or moreof said line spaces on the document display; entering a first commandusing the input device at a user-determined location along a selectedone of said line spaces to assert an insert moving space function, thecomputer and document display being responsive to open a predeterminedamount of added space at said location in the selected line spaceincluding shifting any pre-existing glyphs in the selected line space onone side of said location in a direction along the line away from saidlocation; and entering handwritten script in the added space proceedingin said direction along the line using the input device, the computerand document display being responsive to the entry of the script tosupplement the added space to approximate the amount of added script.12. A method according to claim 11 including setting a triggerpoint atan offset defining a distance from said location in said direction, thecomputer and document display being responsive to entry of added scriptin said direction past the triggerpoint to initiate supplementing of theadded space.
 13. A method according to claim 12 in which the offsetdistance is less than the predetermined amount of added space.
 14. Amethod according to claim 12 in which said offset is set by the user.15. A method according to claim 11 in which the predetermined amount ofadded space is set by the user.
 16. A method according to claim 11 inwhich said location is positioned between adjacent first and secondpre-existing glyphs having an initial glyph spacing, the computer beingresponsive to save said initial glyph spacing.
 17. A method according toclaim 16 including entering a second command to assert a collapse movingspace function, the computer and document display being responsive toclose the added space including shifting the pre-existing glyphs on saidone side of said location along said line toward the added script adistance sufficient to restore said initial glyph spacing relative to anendpoint of the added script.
 18. A method according to claim 11including entering a third command using the input device within theadded space to assert a moving space propagation function, the computerand document display being responsive to the third command to supplementthe added space.
 19. A method according to claim 11 in which the amountof added space is sufficient to shift at least a portion of one or moreof the pre-existing glyphs in the selected line space in said directionpast one of the endpoint and beginning point of the line, the computerand document display being responsive to wrap the glyphs thus shiftedbetween the end and beginning points of successive line spaces.
 20. Amethod according to claim 11 in which the amount of added space issufficient to shift at least a portion of one or more of thepre-existing glyphs in the selected line space rightward past theendpoint of the line, the computer and document display being responsiveto wrap the glyphs shifted past the endpoint to a position rightward ofthe beginning point of the next successive line space.
 21. A methodaccording to claim 11 in which the insert moving space function iscontext sensitive to open a different amount of added space at theuser-determined location of the first command in the selected line spacedepending on whether said location is between glyphs within a word orbetween words.
 22. A method according to claim 11 in which the movingspace remains open for entry of added script while the user entersstrokes elsewhere on the document display.
 23. In a pen-based computer,a dynamic document display in combination with a pen-type electricalinput device, the display comprising:a display window; a group of linesarranged in a parallel, spaced-apart manner on the display window, eachline having beginning and ending points defining a length of each line;and line space segments between the lines, each line space segmentbounded widthwise by a pair of adjacent liens and lengthwise by thelength of an associated one of the lines; the line space segments eachincluding a matrix of data points for receiving and displaying datatherein, and being coupled in series so as to establish continuity ofthe line space segments from an endpoint of a first line to a beginningpoint of a second line; means responsive to a first user action at aselected location in the first line for inserting a first amount ofmoving space in the associated line space segment and shifting a portionof the data displayed in the data points of the associated line spacesegment lengthwise therealong in a predetermined direction away fromsaid location; and means responsive to entry of added data in a portionof the moving space for supplementing the first amount of moving spaceby adding a second amount thereto approximately equal to the portionfilled by the added data and further shifting the previously-shiftedportion of data in said predetermined direction.
 24. A document displayaccording to claim 23 including means for shifting said portion of dataserially across the endpoint of the first line and beginning point ofthe second line to a successive line space segment.
 25. A documentdisplay according to claim 24 in which the data points are organizedinto separable words each having first and last points defining a lengthof the word, the shifting means being operative to shift each word as aunit, including all data points between the first and last points,across the beginning and ending points of lines to the adjoining linespace segment.
 26. A document display according to claim 24 includingmeans for entering a beginning of line (BOL) marker at the beginningpoint of the second line, the shifting means being responsive to the BOLmarker to shift the BOL marker and the data points in the line spacesegment at the second line to a third line.
 27. A document displayaccording to claim 23 including means responsive to a second user actionfor collapsing the moving space by shifting the previously-shiftedportion of data serially in a direction opposite said predetermineddirection toward said added data.
 28. A document display according toclaim 27 in which the data points are organized into separable glyphs orwords each having first and last points and a glyph or word spacingtherebetween, the shifting means including means responsive to a firstuser action for storing the spacing between glyphs or words adjacentsaid location and the means responsive to the second user actionincluding means for restoring a spacing approximately equal to thestored glyph or word spacing upon collapsing of the moving space.
 29. Adocument display according to claim 23 in which the display window isformatted as a page with a margin along one or more of the top, bottom,left and right page boundaries containing said lines, including a marginadjoining one of the beginning and ending points of the lines having awidth that can be varied inversely with the lengths of the lines anddefining a drawing space that is nonresponsive to said means responsiveto a user action for shifting data in the data points lengthwise alongthe line space segments.
 30. A document display according to claim 23including means responsive to a predetermined user action when the addedmoving space is shifted out of a visible area of the display window toautomatically scroll more lines into the visible area.
 31. A pen-basedcomputer method for a user interactively to enter and edit glyphsincluding handwritten script and drawing strokes using a pen-typeelectrical input device on a dynamic document display, the methodcomprising:forming a series of lines, each having a beginning point andan end point, to define line spaces for writing script, each line spacebeing associated with one of said lines; entering handwritten script ordrawing strokes or both in one or more of said line spaces on thedocument display, each stroke comprising a finite series of data pointsincluding a starting point; and encoding the handwritten script ordrawing strokes entered in the line spaces for storage, retrieval anddisplay, including, for each script or drawing stroke: determining andstoring the line associated with the line space to which the strokebelongs; storing a location of the starting point of the stroke withinthe line space; and determining and storing a direction for eachsuccessive data point in the stroke in a format that permitssubstantially replication of the stroke, including storing a datumdefining each occurrence or an absence of a change of direction from onepoint to a successive point.
 32. A method according to claim 31 in whichan initial direction is encoded from the starting point to a secondpoint and a second direction from the second point to a third point isencoded so as to define one of no-change-in-direction from the precedingpoint and a clockwise or counterclockwise change from said direction toestablish a new direction.
 33. A method according to claim 32 includingencoding the initial direction as at least three binary digits, encodingthe no-change-of-direction as a single binary digit, encoding theclockwise or counterclockwise change of direction as at least two binarydigits, and serially concatenating said binary digits for the finiteseries of points in the stroke.
 34. A method according to claim 33including encoding a predetermined number of binary digits defining anumber of data points in each stroke and concatenating said plurality ofbinary digits with the binary digits serially concatenated for thefinite series of points in the stroke.
 35. A method according to claim32 including preprocessing the data points defining each stroke toremove gaps or duplicate data points.
 36. A method according to claim 35in which preprocessing the data points includes searching for series ofthree adjoining data points which form an L and deleting a selected oneof said three points.
 37. A method according to claim 36 in which theselected one of three points is selected by determining which one ofadjoining second and third points forming an L formation with a firstpoint is located at a largest distance in X-Y coordinates from the firstpoint.
 38. A method according to claim 32 including selecting strokeshaving a length exceeding a predetermined maximum length or a change indirection exceeding a predetermined maximum deflection, and dividing theselected strokes into at least two concatenated ministrokes and encodingeach ministroke as a separate stroke.
 39. A method according to claim 31including storing each stroke within a given line space in a strokedatabase according to a leftmost point of each stroke so that thestrokes are ordered from left to right in the database.
 40. A methodaccording to claim 31 in which the line space to which a stroke belongsis determined by the starting point of the stroke.